%% $RCSfile: smatrxcat.ttlc,v $
%% File : smatrxcat.tlc generated from smatrxcat.ttlc revsion 1.3 
%% $Date: 2000/08/09 14:48:37 $
%%
%% Steve Conahan
%% Copyright 1990-2000 The MathWorks, Inc.
%%
%% Abstract: Matrix Concatenation
%%

%implements smatrxcat "C"


%% Function: BlockInstanceSetup ===============================================
%%
%% Abstract:
%%      Rename the S-Function parameters for easy reference.
%%
%function BlockInstanceSetup(block, system) void
  %%
  %assign OUTPORT     = 0
  %assign OUT_COMPLEX = LibBlockOutputSignalIsComplex(OUTPORT)
  %% This gives the real data type name, no matter if input is real or complex:
  %assign OUT_DTYPE_NAME = ...
    LibBlockOutputSignalDataTypeName(OUTPORT,"%<tRealPart>")
  %%
  %assign HORIZONTAL = 1
  %assign CAT_METHOD = SFcnParamSettings.CatMethod
  %%
  %if (CAT_METHOD == HORIZONTAL)
    %% Number of ROWS is constant for all input and output ports
    %assign outDims = LibBlockOutputSignalDimensions(OUTPORT)
    %assign CONST_HORIZROWS_OR_VERTCOLS = outDims[0]
  %else
    %% Number of COLUMNS is constant for all input and output ports
    %assign numOutDims = LibBlockOutputSignalNumDimensions(OUTPORT)
    %assign outDims    = LibBlockOutputSignalDimensions(OUTPORT)
    %assign CONST_HORIZROWS_OR_VERTCOLS = (numOutDims == 2) ? outDims[1] : 1
  %endif %% (CAT_METHOD == HORIZONTAL)
  %%
  %% If the output is complex, determine if ALL inputs are complex
  %% (for code generation optimizations).
  %%
  %if OUT_COMPLEX
    %assign realInputDetected = 0
    %foreach inpCnt = NumDataInputPorts
      %assign realInputDetected = ...
        realInputDetected || ( !LibBlockInputSignalIsComplex(inpCnt) )
    %endforeach
  %else
    %assign realInputDetected = 1
  %endif %% OUT_COMPLEX
  %%
  %if realInputDetected
    %assign ALL_INPUTS_COMPLEX = 0
  %else
    %assign ALL_INPUTS_COMPLEX = 1
  %endif %% realInputDetected
  %%
  %% NOTE: The following only works for SL built-in types 
  %%       (i.e. not for custom types)
  %assign outDtypeId          = LibBlockOutputSignalDataTypeId(OUTPORT)
  %assign numBytesPerRealElmt = SLibGetDataTypeSizeFromId(outDtypeId)
  %assign numBytesPerCplxElmt = 2 * numBytesPerRealElmt
  %%
  %assign block = block + OUTPORT + OUT_COMPLEX + OUT_DTYPE_NAME + ...
                  outDims + numBytesPerRealElmt + numBytesPerCplxElmt
  %assign block = block + HORIZONTAL + CAT_METHOD
  %assign block = block + CONST_HORIZROWS_OR_VERTCOLS + ALL_INPUTS_COMPLEX
%endfunction %% BlockInstanceSetup


%% Function: Outputs ==========================================================
%%
%function Outputs(block, system) Output
%%
  /* 
   * Matrix Concatenation: %<Name>
  %if (NumDataInputPorts > 1)
    %if (CAT_METHOD == HORIZONTAL)
      %<GenerateHorizCatCode(block)>
    %else
      %<GenerateVertCatCode(block)>
    %endif %% (CAT_METHOD == HORIZONTAL)
  %else
    %<GenerateCopyCode(block)>
  %endif %% (NumDataInputPorts > 1)
%endfunction  %% Outputs


%% Function: GenerateCopyCode =============================================
%%
%function GenerateCopyCode(block) Output
  %%
  %% One input port - check and see if we share I/O or not
  %%
  %assign in_place = (LibBlockInputSignalBufferDstPort(0) == OUTPORT)
  %%
  %if in_place
    %% NOTE this comment begins at the very start of the Outputs function
    %% (i.e. "/* Matrix Concatenation...")
    * No code required: input port and output port buffers shared.
    */
  %else
    %if OUT_COMPLEX
      %% NOTE this comment begins at the very start of the Outputs function
      %% (i.e. "/* Matrix Concatenation...")
      * One input, complex, data type: %<OUT_DTYPE_NAME>.
      */
      %assign numBytesPerInputMatrix = ...
        LibBlockInputSignalWidth(0) * numBytesPerCplxElmt
    %else
      %% NOTE this comment begins at the very start of the Outputs function
      %% (i.e. "/* Matrix Concatenation...")
      * One input, real, data type: %<OUT_DTYPE_NAME>.
      */
      %assign numBytesPerInputMatrix = ...
        LibBlockInputSignalWidth(0) * numBytesPerRealElmt
    %endif %% OUT_COMPLEX
    %%
    %assign y = LibBlockOutputSignalAddr(OUTPORT, "", "", 0)
    %assign u = LibBlockInputSignalAddr(0,"","",0)
    (void) memcpy( (byte_T *)%<y>,
      (byte_T *)%<u>, %<numBytesPerInputMatrix> ); ...
      /* [%<outDims[0]>x%<outDims[1]>] */
    %%
  %endif  %% in_place
%endfunction  %% GenerateCopyCode

    
%% Function: GenerateHorizCatCode =============================================
%%
%function GenerateHorizCatCode(block) Output
  %%
  %% There are two cases to consider:
  %%
  %% Easy case (all inputs same complexity) ->
  %%     Render a bunch of memcpy statements (no loops required).
  %%
  %% Mixed case (some inputs real, some inputs complex) ->
  %%     Render a combination of either memcpy 
  %%     statements, or loops based on input port complexity.  Worst case
  %%     for N-1 ports real and 1 port complex is that we render
  %%     N-1 for-loops. Must check each input complexity as we go.
  %%
  %if !OUT_COMPLEX || ALL_INPUTS_COMPLEX
    %<GenHorizCatSameComplexity(block)>
  %else
    %<GenHorizCatDifferentComplexity(block)>
  %endif
%endfunction  %% GenerateHorizCatCode


%% Function: GenerateVertCatCode ==============================================
%%
%function GenerateVertCatCode(block) Output
  %%
  %% Vertical Concatenation:
  %%
  %% There are two cases to consider:
  %%
  %% Easier case -> All inputs same complexity.
  %% Mixed case  -> Some inputs real, some inputs complex.
  %%
  %if !OUT_COMPLEX || ALL_INPUTS_COMPLEX
    %<GenVertCatSameComplexity(block)>
  %else
    %<GenVertCatDifferentComplexity(block)>
  %endif
%endfunction  %% GenerateVertCatCode


%% Function: GenHorizCatSameComplexity ========================================
%%
%function GenHorizCatSameComplexity(block) Output
  %if OUT_COMPLEX
    %% NOTE this comment begins at the very start of the Outputs function
    %% (i.e. "/* Matrix Concatenation...")
    * Horizontal matrix concatenation, 
    * %<NumDataInputPorts> inputs, complex, data type: %<OUT_DTYPE_NAME>.
    */
    %assign numBytesPerElmt = numBytesPerCplxElmt
  %else
    %% NOTE this comment begins at the very start of the Outputs function
    %% (i.e. "/* Matrix Concatenation...")
    * Horizontal matrix concatenation, 
    * %<NumDataInputPorts> inputs, real, data type: %<OUT_DTYPE_NAME>.
    */
    %assign numBytesPerElmt = numBytesPerRealElmt
  %endif %% OUT_COMPLEX
  %%
  %assign byteCount = 0
  %assign y = LibBlockOutputSignalAddr(OUTPORT, "", "", 0)
  %foreach portNum = NumDataInputPorts
    %assign numBytesPerInputMatrix = ...
      LibBlockInputSignalWidth(portNum) * numBytesPerElmt
    %assign inDims = LibBlockInputSignalDimensions(portNum)
    %assign colDim = LibBlockInputSignalWidth(portNum) / inDims[0]
    %% Note: in the unoriented input case, can't use inDims[1]
    %% to determine number of columns
    %assign u = LibBlockInputSignalAddr(portNum, "", "",0)
    %assign comment = "/* Input %<portNum+1>: [%<inDims[0]>x%<colDim>] */"
    %if (byteCount > 0)
      (void) memcpy( ((byte_T *)(%<y>)) + %<byteCount>,
      (byte_T *)%<u>, %<numBytesPerInputMatrix> ); %<comment>
    %else
      (void) memcpy( ((byte_T *)(%<y>)),
      (byte_T *)%<u>, %<numBytesPerInputMatrix> ); %<comment>
    %endif
    %assign byteCount = byteCount + numBytesPerInputMatrix
  %endforeach
%endfunction %% GenHorizCatSameComplexity


%% Function: GenHorizCatDifferentComplexity ===================================
%%
%function GenHorizCatDifferentComplexity(block) Output
%% NOTE this comment begins at the very start of the Outputs function
  %% (i.e. "/* Matrix Concatenation...")
  * Horizontal matrix concatenation, 
  * %<NumDataInputPorts> inputs, real and complex, data type: %<OUT_DTYPE_NAME>.
  */
  %assign dTypeId = LibBlockOutputSignalDataTypeId(0)
  %assign zero = SLibGetFormattedValueFromId(dTypeId, 0)
  %assign outByteCount = 0
  %foreach portNum = NumDataInputPorts
    %assign y = LibBlockOutputSignalAddr(OUTPORT, "", "", 0)
    %assign u = LibBlockInputSignalAddr(portNum, "", "",0)
    %if LibBlockInputSignalIsComplex(portNum)
      %%
      %% Complex input, complex output
      %%
      %assign numBytesPerInputMatrix = ...
        LibBlockInputSignalWidth(portNum) * numBytesPerCplxElmt
      %assign inDims = LibBlockInputSignalDimensions(portNum)
      %assign colDim = LibBlockInputSignalWidth(portNum) / inDims[0]
      %%
      %% Note: in the unoriented input case, can't use inDims[1]
      %% to determine number of columns
      %assign dimStr = "[%<inDims[0]>x%<colDim>]"
      /* Input %<portNum + 1>: [%<inDims[0]>x%<dimStr>], complex */
      %if (outByteCount > 0)
        (void) memcpy( ((byte_T *)(%<y>)) + %<outByteCount>, 
          (byte_T *)%<u>, %<numBytesPerInputMatrix> );
      %else
        (void) memcpy( (byte_T *)%<y>,
          (byte_T *)%<u>, %<numBytesPerInputMatrix> );
      %endif
      %%
      %assign outByteCount = outByteCount + numBytesPerInputMatrix
      %%
    %else
      %%
      %% Real input, complex output
      %%
      %% Note: in the unoriented input case, can't use inDims[1]
      %% to determine number of columns
      %assign inDims = LibBlockInputSignalDimensions(portNum)
      %assign colDim = LibBlockInputSignalWidth(portNum) / inDims[0]
        /* Input %<portNum + 1>: [%<inDims[0]>x%<colDim>], real */
        {
        %if (LibBlockInputSignalWidth(portNum) > 1)
          int_T cnt;
          for ( cnt = 0; cnt < %<LibBlockInputSignalWidth(portNum)>; cnt++ ) {
          /* 
           * Copy real input sample bytes to real part of output, 
           * zeroize imaginary part
           */
          %if (outByteCount > 0)
            (void) memcpy( ((byte_T *)(%<y>))                   ...
              + (cnt * %<numBytesPerCplxElmt>) + %<outByteCount>,
              ((byte_T *)(%<u>)) +                                   ...
              (cnt * %<numBytesPerRealElmt>), %<numBytesPerRealElmt> );
            %% NOTE: The following only works for SL built-in types
            %% (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((char *) %<y>) ...
                + (cnt * %<numBytesPerCplxElmt>) ...
                + %<outByteCount + numBytesPerRealElmt>) = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>))          ...
                + (cnt * %<numBytesPerCplxElmt>)         ...
                + %<outByteCount + numBytesPerRealElmt>, ...
                0, %<numBytesPerRealElmt> );
            %endif
          %else
            (void) memcpy( ((byte_T *)(%<y>))   ...
              + (cnt * %<numBytesPerCplxElmt>), 
              ((byte_T *)(%<u>))                                       ...
              + (cnt * %<numBytesPerRealElmt>), %<numBytesPerRealElmt> );
            %% NOTE: The following only works for SL built-in types
            %% (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) ...
                + (cnt * %<numBytesPerCplxElmt>) + %<numBytesPerRealElmt>) ...
                = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>)) ...
                + (cnt * %<numBytesPerCplxElmt>) + %<numBytesPerRealElmt>, ...
                0, %<numBytesPerRealElmt> );
            %endif
          %endif
          } /* end cnt */
          %% Increment output bytes for next element
          %assign outByteCount = outByteCount + ...
            (numBytesPerCplxElmt * LibBlockInputSignalWidth(portNum))
        %else
          /* 
           * Copy real input sample bytes to real part of output, 
           * zeroize imaginary part 
           */
          %if (outByteCount > 0)
            (void) memcpy( ((byte_T *)(%<y>)) + %<outByteCount>,
              (byte_T *)%<u>, %<numBytesPerRealElmt> );
            %% NOTE: The following only works for SL built-in types
            %% (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) ...
                + %<outByteCount> + %<numBytesPerRealElmt>) ...
                = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>)) + %<outByteCount> ...
                + %<numBytesPerRealElmt>, ...
                0, %<numBytesPerRealElmt> );
            %endif
            %% Increment output bytes for next element
            %assign outByteCount = outByteCount + numBytesPerCplxElmt
          %else
            (void) memcpy( (byte_T *)%<y>,
              (byte_T *)%<u>, %<numBytesPerRealElmt> );
            %% NOTE: The following only works for SL built-in types
            %%  (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) ...
                + %<numBytesPerRealElmt>) = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>)) + %<numBytesPerRealElmt>, ...
                0, %<numBytesPerRealElmt> );
            %endif
            %% Increment output bytes for next element
            %assign outByteCount = outByteCount + numBytesPerCplxElmt
          %endif
        %endif %% (LibBlockInputSignalWidth(portNum) > 1)
      }
    %endif  %% complex vs. real input
  %endforeach %% portNum
%endfunction %% GenHorizCatDifferentComplexity


%% Function: GenVertCatSameComplexity ========================================
%%
%function GenVertCatSameComplexity(block) Output
  %if OUT_COMPLEX
    %% NOTE this comment begins at the very start of the Outputs function
    %% (i.e. "/* Matrix Concatenation...")
    * Vertical matrix concatenation, 
    * %<NumDataInputPorts> inputs, complex, data type: %<OUT_DTYPE_NAME>.
    */
    %assign numBytesPerElmt = numBytesPerCplxElmt
  %else
    %% NOTE this comment begins at the very start of the Outputs function
    %% (i.e. "/* Matrix Concatenation...")
    * Vertical matrix concatenation, 
    * %<NumDataInputPorts> inputs, real, data type: %<OUT_DTYPE_NAME>.
    */
    %assign numBytesPerElmt = numBytesPerRealElmt
  %endif %% OUT_COMPLEX
  {
  %assign byteCount = 0
  %assign y = LibBlockOutputSignalAddr(OUTPORT, "", "", 0)
  %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
    const int_T nCols = %<CONST_HORIZROWS_OR_VERTCOLS>;
    int_T       colNum;
    for ( colNum = 0; colNum < nCols; colNum++ ) {
    %%
    %% Calculate total number of bytes per output column for use below
    %assign totNumOutColBytes = 0
    %foreach portNum = NumDataInputPorts
      %assign inDims   = LibBlockInputSignalDimensions(portNum)
      %assign colBytes = inDims[0] * numBytesPerElmt
      %assign totNumOutColBytes = totNumOutColBytes + colBytes
    %endforeach %% NumDataInputPorts
    %%
    %foreach portNum = NumDataInputPorts
      %assign u        = LibBlockInputSignalAddr(portNum, "", "",0)
      %assign inDims   = LibBlockInputSignalDimensions(portNum)
      %assign colDim   = LibBlockInputSignalWidth(portNum) / inDims[0]
      %assign colBytes = inDims[0] * numBytesPerElmt
      %assign dimStr   = "[%<inDims[0]>x%<colDim>], %<colBytes> bytes per col"
      %assign comment  = "/* Input %<portNum + 1>: %<dimStr> */"
      %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
        %if (byteCount > 0)
          (void) memcpy( ((byte_T *)(%<y>))                 ...
            + (colNum * %<totNumOutColBytes>) + %<byteCount>,
            ((byte_T *)(%<u>))                                ...
            + (colNum * %<colBytes>), %<colBytes> ); %<comment>
        %else
          (void) memcpy( ((byte_T *)(%<y>))  ...
            + (colNum * %<totNumOutColBytes>),
            ((byte_T *)(%<u>))                                ...
            + (colNum * %<colBytes>), %<colBytes> ); %<comment>
        %endif
      %else
        %if (byteCount > 0)
          (void) memcpy( ((byte_T *)(%<y>))                 ...
            + (colNum * %<totNumOutColBytes>) + %<byteCount>,
            (byte_T *)(%<u>), %<colBytes> ); %<comment>
        %else
          (void) memcpy( ((byte_T *)(%<y>))  ...
            + (colNum * %<totNumOutColBytes>),
            (byte_T *)(%<u>), %<colBytes> ); %<comment>
        %endif
      %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
      %assign byteCount = byteCount + colBytes
    %endforeach %% input port number
    }
  %else
    %foreach portNum = NumDataInputPorts
      %assign u        = LibBlockInputSignalAddr(portNum, "", "",0)
      %assign inDims   = LibBlockInputSignalDimensions(portNum)
      %assign colDim   = LibBlockInputSignalWidth(portNum) / inDims[0]
      %assign colBytes = inDims[0] * numBytesPerElmt
      %assign dimStr   = "[%<inDims[0]>x%<colDim>], %<colBytes> bytes per col"
      %assign comment  = "/* Input %<portNum + 1>: %<dimStr> */"
      %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
        %if (byteCount > 0)
          (void) memcpy( ((byte_T *)(%<y>)) + %<byteCount>,
          ((byte_T *)(%<u>))                                ...
          + (colNum * %<colBytes>), %<colBytes> ); %<comment>
        %else
          (void) memcpy( (byte_T *)(%<y>), 
          ((byte_T *)(%<u>))                                ...
          + (colNum * %<colBytes>), %<colBytes> ); %<comment>
        %endif
      %else
        %if (byteCount > 0)
          (void) memcpy( ((byte_T *)(%<y>)) + %<byteCount>,
            (byte_T *)(%<u>), %<colBytes> ); %<comment>
        %else
          (void) memcpy( (byte_T *)(%<y>),
            (byte_T *)(%<u>), %<colBytes> ); %<comment>
        %endif
      %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
      %assign byteCount = byteCount + colBytes
    %endforeach %% input port number
  %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
  }
%endfunction %% GenVertCatSameComplexity


%% Function: GenVertCatDifferentComplexity ====================================
%%
%function GenVertCatDifferentComplexity(block) Output
  %% NOTE this comment begins at the very start of the Outputs function
  %% (i.e. "/* Matrix Concatenation...")
  * Vertical matrix concatenation, 
  * %<NumDataInputPorts> inputs, real and complex, data type: %<OUT_DTYPE_NAME>.
  */
  %assign dTypeId = LibBlockOutputSignalDataTypeId(0)
  %assign zero = SLibGetFormattedValueFromId(dTypeId, 0)
  {
    int_T       outputByteCount = 0;
    %%
    %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
      %assign totOutColBytes = NumDataInputPorts * ...
      CONST_HORIZROWS_OR_VERTCOLS * numBytesPerCplxElmt
      const int_T nCols = %<CONST_HORIZROWS_OR_VERTCOLS>;
      int_T       colNum;
      for ( colNum = 0; colNum < nCols; colNum++ ) {
    %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
    %%
    %assign y = LibBlockOutputSignalAddr(OUTPORT, "", "", 0)
    %foreach portNum = NumDataInputPorts
      %assign u        = LibBlockInputSignalAddr(portNum, "", "",0)
      %assign inDims   = LibBlockInputSignalDimensions(portNum)
      %assign colDim   = LibBlockInputSignalWidth(portNum) / inDims[0]
      %if LibBlockInputSignalIsComplex(portNum)
        %%
        %% Complex input, complex output
        %%
        %assign colBytes = inDims[0] * numBytesPerCplxElmt
        %assign dimStr = "[%<inDims[0]>x%<colDim>], complex," + ...
                         " %<colBytes> bytes per col"
        /* Input %<portNum + 1>: %<dimStr> */
        %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
          (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
            ((byte_T *)(%<u>)) + (colNum * %<colBytes>), %<colBytes> );
        %else
          (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
            (byte_T *)%<u>, %<colBytes> );
        %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
        %% INCREMENT BYTE COUNT FROM THE (COMPLEX) MEMCPY
        outputByteCount += %<colBytes>;
      %else
        %%
        %% Real input, complex output
        %%
        %assign colBytes = inDims[0] * numBytesPerRealElmt
        %if (inDims[0] > 1)
          %assign dimStr = "[%<inDims[0]>x%<colDim>], real," + ...
                         " %<colBytes> bytes per col"
          /* Input %<portNum + 1>: %<dimStr> */
          {
            int_T cnt;                            
            for ( cnt = 0; cnt < %<inDims[0]>; cnt++ ) {
            /* 
             * Copy real input sample bytes to real part of output,
             * zeroize imaginary part
             */
            %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
              (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
                ((byte_T *)(%<u>)) + (colNum * %<colBytes>)              ...
                + (cnt * %<numBytesPerRealElmt>), %<numBytesPerRealElmt> );
              %% INCREMENT BYTE COUNT FROM THE REAL PART MEMCPY
              outputByteCount += %<numBytesPerRealElmt>;
              %% NOTE: The following only works for SL built-in types
              %% (i.e. not for custom types)
              %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
                *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) + outputByteCount) ...
                  = %<zero>;
              %else
                (void) memset( ((byte_T *)(%<y>)) + outputByteCount, ...
                                           0, %<numBytesPerRealElmt> );
              %endif
            %else
              (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
                ((byte_T *)(%<u>))                                       ...
                + (cnt * %<numBytesPerRealElmt>), %<numBytesPerRealElmt> );
              %% INCREMENT BYTE COUNT FROM THE REAL PART MEMCPY
              outputByteCount += %<numBytesPerRealElmt>;
              %% NOTE: The following only works for SL built-in types 
              %% (i.e. not for custom types)
              %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
                *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) + outputByteCount) ...
                  = %<zero>;
              %else
                (void) memset( ((byte_T *)(%<y>)) + outputByteCount, ...
                                           0, %<numBytesPerRealElmt> );
              %endif
            %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
            %% INCREMENT BYTE COUNT FROM THE ZEROIZATION OF IMAG PART
            outputByteCount += %<numBytesPerRealElmt>;
            }
          }
        %else
          %assign dimStr = "[%<inDims[0]>x%<colDim>], real," + ...
                           " %<colBytes> bytes per col"
          /* Input %<portNum + 1>: %<dimStr>
           * Copy real input sample bytes to real part of output,
           * zeroize imaginary part
           */
          %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
             (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
          ((byte_T *)%<u>) + (colNum * %<colBytes>), %<numBytesPerRealElmt> );
            outputByteCount += %<numBytesPerRealElmt>;
            %% NOTE: The following only works for SL built-in types
            %% (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((char *)%<y>) + outputByteCount) ...
                = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>)) + outputByteCount, ...
                                         0, %<numBytesPerRealElmt> );
            %endif
          %else
            (void) memcpy( ((byte_T *)(%<y>)) + outputByteCount,
              (byte_T *)%<u>, %<numBytesPerRealElmt> );
            outputByteCount += %<numBytesPerRealElmt>;
            %% NOTE: The following only works for SL built-in types
            %% (i.e. not for custom types)
            %if ((dTypeId == tSS_DOUBLE) || (dTypeId == tSS_SINGLE))
              *(%<OUT_DTYPE_NAME> *)(((byte_T *)(%<y>)) + outputByteCount) ...
                = %<zero>;
            %else
              (void) memset( ((byte_T *)(%<y>)) + outputByteCount, ...
                                         0, %<numBytesPerRealElmt> );
            %endif
          %endif %% (CONST_HORIZROWS_OR_VERTCOLS > 1)
          %% INCREMENT BYTE COUNT FROM THE ZEROIZATION OF IMAG PART
          %% [AVOID EXTRA UNUSED LINE OF CODE FOR FINAL INCREMENT]
          %if ((portNum+1) < NumDataInputPorts)
            outputByteCount += %<numBytesPerRealElmt>;
          %endif
        %endif %% (inDims[0] > 1)
      %endif %% complex vs. real input
    %endforeach %% input port number
    %%
    %if (CONST_HORIZROWS_OR_VERTCOLS > 1)
    }
    %endif
  }
%endfunction %% GenVertCatDifferentComplexity

%% [EOF] smatrxcat.ttlc