%% $RCSfile: sdspcumsum.tlc,v $
%% $Revision: 1.5 $  $Date: 2000/05/11 18:43:32 $
%%
%% Copyright (c) 1995-2000 The MathWorks, Inc.
%%
%% Abstract: Target file for the S-Function sdspcumsum.c
%%

%implements "sdspcumsum" "C"


%% Function: BlockInstanceSetup ===============================================
%%
%function BlockInstanceSetup(block, system) void

    %assign INPORT  = 0
    %assign OUTPORT = 0

    %assign numDims = LibBlockInputSignalNumDimensions(INPORT)
    %assign inDims  = LibBlockInputSignalDimensions(INPORT)
    %assign inCols  = (numDims == 2) ? inDims[1] : 1
    %assign inRows  = inDims[0]

    %assign cmplx   = LibBlockOutputSignalIsComplex(OUTPORT)
    %assign DType   = cmplx ? "creal_T" : "real_T"

    %assign framebased = LibBlockInputSignalIsFrameData(INPORT)

    %assign block = block  + INPORT + OUTPORT + numDims + ...
                    inCols + inRows + cmplx   + DType   + ...
                    framebased

%endfunction %% BlockInstanceSetup

%% Function: Start =============================================================
%% Abstract:
%%
%function Start(block, system) Output
  %%
  %if !LibIsEqual(TID, "constant")
    %%
    %if framebased
        {
            %<DType> *rcumsum = %<LibBlockDWorkAddr(RunningCumsum,"","",0)>;
            int_T i;
            for(i=0; i<%<inCols>; i++){
                %if !cmplx
                    *rcumsum++ = 0.0;
                %else
                    rcumsum->re = 0.0;
                    (rcumsum++)->im = 0.0;
                %endif
            }
        }
    %endif
  %endif
    %%
%endfunction  %% Start


%% Function: Outputs ==========================================================
%%
%% Compute cumulative sum of input elements
%%
%function Outputs(block, system) Output
  /* DSP Blockset Cumulative Sum (%<ParamSettings.FunctionName>) - %<Name> */
  %%
  %assign inplace   = (LibBlockInputSignalBufferDstPort(INPORT) == OUTPORT)
  %assign direction = SFcnParamSettings.Direction
  %assign RowCumsum = (direction == 1) && numDims==2
  %assign ColCumsum = (direction == 2) && numDims==2
  %%
  %% Certain cases don't require any code
  %%  - Col Cumsum of a row
  %%  - Row Cumsum of a col
  %%  - Scalar
  %%
  %if (ColCumsum && inRows==1) || ...     
      (RowCumsum && inCols==1) || ...
      (inRows==1 && inCols==1)       
    %%
    %if inplace
        /* No code gnerated for cumulative Sum block because input is not modified. */
    %else
        %assign u     = LibBlockInputSignal(INPORT,"i","",0)
        %assign y     = LibBlockOutputSignal(OUTPORT,"i","",0)
        %%
        %assign uptr  = LibBlockInputSignalAddr(INPORT,"","",0)
        %assign yptr  = LibBlockOutputSignalAddr(OUTPORT,"","",0)
        %assign width = LibDataInputPortWidth(INPORT)
        %%
        /* Copy input to output because data is unchanged. */
        memcpy(%<yptr>,%<uptr>,%<width>*sizeof(%<DType>));

    %endif
    %%
  %else
    {
        %if numDims == 1
            %if inplace
                /* Cumulative sum vector using in-place algorithm */
                %<CumsumVectorInPlace(inRows)> \
            %else
                /* Cumulative sum vector */
                %<CumsumVector(inRows)> \
            %endif
            %%
        %elseif ColCumsum  
            %%
            %if framebased
                %if inplace
                    /* Running cumulative sum using in-place algorithm */
                    %<CumsumRunningInPlace()> \
                %else
                    /* Running cumulative sum */
                    %<CumsumRunning()> \
                %endif
            %else
                %if inplace
                    /* Cumulative sum columns using in-place algorithm */
                    %<CumsumColInPlace()> \
                %else
                    /* Cumulative sum columns */
                    %<CumsumCol()> \
                %endif
            %endif
            %%
        %elseif RowCumsum
            %%
            %if inplace
                /* Cumulative sum rows using in-place algorithm */
                %<CumsumRowInPlace()> \
            %else
                /* Cumulative sum rows */
                %<CumsumRow()> \
            %endif
        %endif
    }
  %endif

%endfunction %% Outputs


%% Function: CumsumRunningInPlace ==========================================================
%%
%function CumsumRunningInPlace() Output 
%%
    %<DType> *rcumsum = %<LibBlockDWorkAddr(RunningCumsum,"","",0)>;
    %<DType> *y       = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
    int_T     rows    = %<inRows>;
    int_T     cols    = %<inCols>;
    int_T     r, c;
    %<DType> *yprev;

    for(c=0; c<cols; c++) {
        %if !cmplx
            *y     += *rcumsum;
        %else
             y->re += rcumsum->re;
             y->im += rcumsum->im;
        %endif
        %%
        yprev  = y++;  

        for(r=1; r<rows; r++) {
            %if cmplx
                y->re     += yprev->re;
                (y++)->im += (yprev++)->im;
            %else
                *y++ += *yprev++;
            %endif
        }
        *rcumsum++ = *yprev;  /* Save cumulative sum for next frame. */
    }
    %%
%endfunction  %% CumsumRunningInPlace


%% Function: CumsumRunning ==========================================================
%%
%function CumsumRunning() Output 
%%
    %<DType> *rcumsum = %<LibBlockDWorkAddr(RunningCumsum,"","",0)>;
    %<DType> *u       = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
    %<DType> *y       = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
    int_T     rows    = %<inRows>;
    int_T     cols    = %<inCols>;
    int_T     r, c;
    %<DType> *yprev;

    for(c=0; c<cols; c++) {
        %if !cmplx
            *y = *u++ + *rcumsum;  
        %else
            y->re = u->re + rcumsum->re;
            y->im = (u++)->im + rcumsum->im;
        %endif
        %%
        yprev = y++;    

        for(r=1; r<rows; r++) {
            %if !cmplx
                *y++ = *u++ + *yprev++;
            %else
                y->re     = u->re + yprev->re;
                (y++)->im = (u++)->im + (yprev++)->im;      
            %endif
        }
        *rcumsum++ = *yprev;  /* Save cumulative sum for next frame. */
    }
    %%
%endfunction  %% CumsumRunning


%% Function: CumsumColInPlace ==========================================================
%%
%function CumsumColInPlace() Output 
%%
    %if inCols > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T     rows = %<inRows>;
        int_T     cols = %<inCols>;
        int_T     r, c;

        for(c=0; c<cols; c++) {
            %<DType> *yprev = y++;  /* Skip over first element */

            for(r=1; r<rows; r++) {
                %if cmplx
                    y->re     += yprev->re;
                    (y++)->im += (yprev++)->im;
                %else
                    *y++ += *yprev++;
                %endif
            }
        }
    %else
        %<CumsumVectorInPlace(inRows)> \        
    %endif
    %%
%endfunction  %% CumsumColInPlace


%% Function: CumsumCol ==========================================================
%%
%function CumsumCol() Output 
%%
    %if inCols > 1
        %%
        %% Matrix code
        %%  
        %<DType> *u    = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T     rows = %<inRows>;
        int_T     cols = %<inCols>;
        int_T     r, c;

        for(c=0; c<cols; c++) {
            %<DType> *yprev = y;
            *y++ = *u++;  
    
            for(r=1; r<rows; r++) {
                %if cmplx
                    y->re     = u->re + yprev->re;
                    (y++)->im = (u++)->im + (yprev++)->im;      
                %else
                    *y++ = *u++ + *yprev++;
                %endif
            }
        }
    %else
        %<CumsumVector(inRows)> \        
    %endif
    %%
%endfunction  %% CumsumCol


%% Function: CumsumRowInPlace ==========================================================
%%
%function CumsumRowInPlace() Output 
%%
    %if inRows > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T     rows = %<inRows>;
        int_T     cols = %<inCols>;
        int_T     r, c;

        for(r=0; r<rows; r++) {
            for(c=1; c<cols; c++) {
                int_T idx = c * rows;
                %%
                %if cmplx
                    int_T idxprev = idx - rows;

                    y[idx].re += y[idxprev].re;
                    y[idx].im += y[idxprev].im;
                %else
                    y[idx] += y[idx - rows];
                %endif
            }
            y++;  /* next row */
        }
    %else
        %<CumsumVectorInPlace(inCols)> \        
    %endif
    %%
%endfunction  %% CumsumRowInPlace


%% Function: CumsumRow ==========================================================
%%
%function CumsumRow() Output 
%%
    %if inRows > 1
        %%
        %% Matrix code
        %%  
        %<DType> *u    = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T     rows = %<inRows>;
        int_T     cols = %<inCols>;
        int_T     r, c;

        for(r=0; r<rows; r++) {
            *y     = *u;  

            for(c=1; c<cols; c++) {
                int_T idx   = c * rows;
                %%
                %if cmplx
                    int_T idxprev = idx - rows;

                    y[idx].re = y[idxprev].re + u[idx].re;
                    y[idx].im = y[idxprev].im + u[idx].im;
                %else
                    y[idx] = y[idx - rows] + u[idx];
                %endif
            }
            u++;   /* next input row */
            y++;   /* next output row */
        }
    %else
        %<CumsumVector(inCols)> \        
    %endif
    %%
%endfunction  %% CumsumRow


%% Function: CumsumVectorInPlace ==========================================================
%%
%function CumsumVectorInPlace(width) Output 
%%
    %<DType> *y     = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
    %<DType> *yprev = y++;
    int_T    width  = %<width>;

    while(width-- > 1) {
        %if cmplx
            y->re     += yprev->re;
            (y++)->im += (yprev++)->im;
        %else
            *y++ += *yprev++;
        %endif
    }
%%
%endfunction  %% CumsumVector


%% Function: CumsumVector ==========================================================
%%
%function CumsumVector(width) Output 
%%
    %<DType> *u     = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
    %<DType> *y     = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
    int_T     width = %<width>;

    %<DType> *yprev = y;
    *y++ = *u++;  

    while(width-- > 1) {
        %if cmplx
            y->re     = u->re + yprev->re;
            (y++)->im = (u++)->im + (yprev++)->im;      
        %else
            *y++ = *u++ + *yprev++;
        %endif
    }
%%
%endfunction  %% CumsumVector


%% EOF: sdspcumsum.tlc