%% Function: ================================================
%% Abstract: Render the channel and frame loops and call to initialize the seed
%%
%function DSP_RenderInitializeSeedLoop(nchans,multipleChans,IS_COMPLEX,seedLen) Output
%%
    %if multipleChans
      int_T   i;
      %if seedLen == 1
        real_T seedVal = %<LibBlockParameter(InitSeed,"","",0)>;
      %else
        real_T *pSeeds = (real_T *)%<LibBlockParameterAddr(InitSeed,"","",0)>;
      %endif
            
        for (i=0;i<%<nchans>;i++) {
          %if seedLen > 1 
            real_T seedVal = pSeeds[i];
          %endif
    %endif
    %%
    %<DSP_Call_To_InitializeSeed(multipleChans,IS_COMPLEX,seedLen)>\
    %%
    %if multipleChans
      %if seedLen == 1
        seedVal += 2.0;
      %endif
        }
    %endif

%endfunction %% DSP_RenderInitializeSeedLoop


%% Function: ================================================
%% Abstract:  Call the function to initialize the seeds based on complexity
%%
%function DSP_Call_To_InitializeSeed(multipleChans,IS_COMPLEX,seedLen) Output
%%
  %if (IS_COMPLEX)
    %if multipleChans
      DSP_InitializeSeed(&urandSeed->re,seedVal);
      DSP_InitializeSeed(&urandSeed->im,seedVal+1);
      urandSeed++;
    %else
      DSP_InitializeSeed((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re,%<LibBlockParameter(InitSeed,"","",0)>);
      DSP_InitializeSeed((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im,%<LibBlockParameter(InitSeed,"","",0)>+1);           
    %endif
  %else 
    %if multipleChans
      DSP_InitializeSeed(urandSeed++,seedVal);
    %else
      DSP_InitializeSeed((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>,%<LibBlockParameter(InitSeed,"","",0)>);
    %endif
  %endif
%endfunction %% DSP_Call_To_InitializeSeed


%% Function: ================================================
%% Abstract:
%function DSP_CallRandomNumberGenerator(IS_COMPLEX,IS_UNIFORM) Output
%%    
    %if (IS_COMPLEX) 
        %if (IS_UNIFORM)
            /* Generate complex uniform random numbers */
            y->re     = DSP_UniformRand(&urandSeed->re) * (*pMax - *pMin) + *pMin; 
            (y++)->im = DSP_UniformRand(&urandSeed->im) * (*pMax - *pMin) + *pMin;
        %else
            /* Generate complex normal (gaussian) random numbers */
            %assign isMeanComplex = CAST("Boolean",(Mean.ComplexSignal == "yes"))
            %if (isMeanComplex)                
                y->re     = DSP_NormalRand(&urandSeed->re) * sqrt(*pVar/2) + pMean->re;
                (y++)->im = DSP_NormalRand(&urandSeed->im) * sqrt(*pVar/2) + pMean->im;
            %else
                y->re     = DSP_NormalRand(&urandSeed->re) * sqrt(*pVar/2) + *pMean;
                (y++)->im = DSP_NormalRand(&urandSeed->im) * sqrt(*pVar/2);
            %endif
        %endif          
    %else    
        %% Real Case
        %if (IS_UNIFORM)
            /* Generate real uniform random numbers */
            *y++ = DSP_UniformRand(urandSeed) * (*pMax - *pMin) + *pMin;
        %else
            /* Generate real normal (gaussian) random numbers */
            *y++ = DSP_NormalRand(urandSeed) * sqrt(*pVar) + *pMean;
        %endif
    %endif
%endfunction %% DSP_CallRandomNumberGenerator


%% Function: ================================================
%% Abstract:
%%      Determine if data is a non-scalar frame.
%%      Note that frameSize must be > 1 even when the input
%%      is continuous, e.g., could not be a frame.
%%
%function InputIsNonscalarFrame(frameSize, TID) void

%return (LibIsDiscrete(TID) && frameSize > 1)

%endfunction %% InputIsNonscalarFrame


%% Function: ================================================
%% Abstract:
%function DSP_ScalarUniformNumGen(IS_COMPLEX,OUTPORT_NUM) Output
%%    
    %assign minVal = LibBlockParameterValue(Min,0)
    %assign scale  = LibBlockParameterValue(Max,0) - minVal
    /* Uniform: all scalar inputs */
    %if (IS_COMPLEX)         
            /* Generate complex uniform random numbers */
            %%            
            %if scale == 1 &&  minVal == 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re); 
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im);
                %%
            %elseif scale == 1 &&  minVal != 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re)
                                                                     + %<minVal>;; 
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im)
                                                                     + %<minVal>;;
                %%
            %elseif LibBlockParameterValue(Min,0) == 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re)
                                                                     * %<scale>; 
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im)
                                                                    * %<scale>;
            %else
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re)
                                                                    * %<scale> + %<minVal>; 
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im) 
                                                                    * %<scale> + %<minVal>;
            %endif            
    %else    %% Real Case
            /* Generate real uniform random numbers */

            %if scale == 1 && minVal == 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>);
                %%
            %elseif scale == 1 &&  minVal != 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) 
                                                                    + %<minVal>;
            %elseif LibBlockParameterValue(Min,0) == 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) 
                                                                * %<scale>;
            %else
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_UniformRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) 
                                                                * %<scale> + %<minVal>;
            %endif
    %endif

%endfunction %% DSP_ScalarUniformNumGen

%% Function: ================================================
%% Abstract:
%function DSP_ScalarGaussianNumGen(IS_COMPLEX,OUTPORT_NUM) Output
%%    
    %assign varVal  = LibBlockParameterValue(Variance,0)
    %%
    %if (IS_COMPLEX) 
        /* Generate complex normal (gaussian) random numbers */
        %%
        %assign isMeanComplex = CAST("Boolean",(Mean.ComplexSignal == "yes"))
        %assign meanVal_re    = CAST("Number",LibBlockParameterValue(Mean,"%<tRealPart>0"))
        %%
        %if varVal != 0 && varVal != 2
            {
                real_T sqrt_var = sqrt(%<varVal>/2);
        %endif
        %%        
        %if (isMeanComplex)    
            %%                
            %assign meanVal_im = CAST("Number",LibBlockParameterValue(Mean,"%<tImagPart>0"))
            %%
            %if varVal == 0    && meanVal_re != 0 && meanVal_im != 0 
                %%        
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = %<meanVal_im>;
                %%
            %elseif  varVal == 2 && meanVal_re == 0 && meanVal_im != 0
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re);
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im) + %<meanVal_im>;
                %%
            %elseif varVal == 2    && meanVal_re != 0 && meanVal_im != 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re) + %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im) + %<meanVal_im>;
            %else
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re) * sqrt_var + %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im) * sqrt_var + %<meanVal_im>;
            %endif    
            %%
        %else %% Output is Complex, Mean is not complex
            %%
            %if varVal == 0 && meanVal_re == 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = 0.0;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = 0.0;
                %%
            %elseif varVal == 0 && meanVal_re != 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = 0.0;
                %%
            %elseif  varVal == 2 && meanVal_re == 0 
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re);
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im);
                %%
            %elseif varVal == 2    && meanVal_re != 0
                %%
                /* start real mean variance = 2 */
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.re) + %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im);
                /* end real mean var = 2 */
                %%
            %elseif meanVal_re == 0 && varVal != 0
                %%
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) * sqrt_var;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>.im) * sqrt_var;    
                %%
            %else
                %%                                                                                                               
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.re = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","","%<tRealPart>0")>) * sqrt_var + %<meanVal_re>;
                %<LibBlockOutputSignal(OUTPORT_NUM,"","",0)>.im = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","","%<tImagPart>0")>) * sqrt_var;
            %endif
        %endif
        %%
        %if varVal != 0 && varVal != 2    
                }
        %endif

    %else    %% Real Case
        /* Generate real normal (gaussian) random numbers */
        %%
        %assign meanVal = LibBlockParameterValue(Mean,0)
        %%
        %if varVal != 0 && varVal != 1
        {
            real_T sqrt_var = sqrt(%<varVal>);
        %endif
        %%
            %if varVal == 1 && meanVal == 0
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>);
                %%    
            %elseif varVal == 0    
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = %<meanVal>;
                %%
            %elseif varVal == 1
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) + %<meanVal>;
                %%
            %elseif meanVal == 0
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) * sqrt_var;
                %%
            %else
                %<LibBlockOutputSignal(OUTPORT_NUM,"0","",0)> = DSP_NormalRand((uint32_T *)%<LibBlockDWorkAddr(RAND_SEED,"","",0)>) * sqrt_var + %<meanVal>;
            %endif    
            %%
        %if varVal != 0 && varVal != 1
        }
        %endif        
    %endif

%endfunction %% DSP_ScalarGaussianNumGen


%% Function: DetermineChannels ================================================
%% Abstract: 
%%      Determine how many channels this block has
%%
%function DetermineChannels() void

  %assign OUTPORT_NUM = 0
  %if (SFcnParamSettings.IsDiscrete == "Yes")
    %assign seedLen = LibGetNumberOfElements(InitSeed.Value)
    %if src_type == "Uniform"
      %assign maxVal = Max.Value
      %assign maxLen = LibGetNumberOfElements(maxVal)
      %assign minVal = Min.Value
      %assign minLen = LibGetNumberOfElements(minVal)
      %% Number of channels == the longest parameter length 
      %assign nchans = MAX(MAX(minLen,maxLen),seedLen)
    %else
      %assign meanVal = Mean.Value
      %assign meanLen = LibGetNumberOfElements(meanVal)
      %assign varVal  = Variance.Value
      %assign varLen  = LibGetNumberOfElements(varVal)
      %% Number of channels == the longest parameter length 
      %assign nchans  = MAX(MAX(meanLen,varLen),seedLen)
    %endif

    %% If we are back-propagating output dimensions/frames
    %% then we need to take into account that the output
    %% size may be larger than the sizes of any param vectors
    %% This is true if we have multiple channels in output
    %% and num output channels greater than any param vector length.
    %if INHERIT_ON
      %assign numDims = LibBlockOutputSignalNumDimensions(OUTPORT_NUM)
      %assign dims    = LibBlockOutputSignalDimensions(OUTPORT_NUM)
      %if (numDims > 1)
        %% If num cols > 1, then multiple channels.
        %if (dims[1] > 1)
          %assign nchans = MAX(nchans,dims[1])
        %endif
        %% We are not taking into account the following:
        %% 1) Column vector, sample-based (nchans = width)
        %% 2) 1-D vector (nchans = width)
      %endif
    %endif  
  %else
    %% Continuous output
    %assign nchans = LibBlockOutputSignalWidth(OUTPORT_NUM)
  %endif
    
  %return nchans
  
%endfunction


%% [EOF] sdsprandsrc.tlc