arm_cmplx_mult_real_f32.c

00001 /* ----------------------------------------------------------------------  
00002 * Copyright (C) 2010 ARM Limited. All rights reserved.  
00003 *  
00004 * $Date:        29. November 2010  
00005 * $Revision:    V1.0.3  
00006 *  
00007 * Project:      CMSIS DSP Library  
00008 * Title:        arm_cmplx_mult_real_f32.c  
00009 *  
00010 * Description:  Floating-point complex by real multiplication  
00011 *  
00012 * Target Processor: Cortex-M4/Cortex-M3
00013 *  
00014 * Version 1.0.3 2010/11/29 
00015 *    Re-organized the CMSIS folders and updated documentation.  
00016 *   
00017 * Version 1.0.2 2010/11/11  
00018 *    Documentation updated.   
00019 *  
00020 * Version 1.0.1 2010/10/05   
00021 *    Production release and review comments incorporated.  
00022 *  
00023 * Version 1.0.0 2010/09/20   
00024 *    Production release and review comments incorporated.  
00025 * -------------------------------------------------------------------- */ 
00026  
00027 #include "arm_math.h" 
00028  
00029 /**  
00030  * @ingroup groupCmplxMath  
00031  */ 
00032  
00033 /**  
00034  * @defgroup CmplxByRealMult Complex-by-Real Multiplication  
00035  *  
00036  * Multiplies a complex vector by a real vector and generates a complex result.  
00037  * The data in the complex arrays is stored in an interleaved fashion  
00038  * (real, imag, real, imag, ...).  
00039  * The parameter <code>numSamples</code> represents the number of complex  
00040  * samples processed.  The complex arrays have a total of <code>2*numSamples</code>  
00041  * real values while the real array has a total of <code>numSamples</code>  
00042  * real values.  
00043  *  
00044  * The underlying algorithm is used:  
00045  *  
00046  * <pre>  
00047  * for(n=0; n<numSamples; n++) {  
00048  *     pCmplxDst[(2*n)+0] = pSrcCmplx[(2*n)+0] * pSrcReal[n];  
00049  *     pCmplxDst[(2*n)+1] = pSrcCmplx[(2*n)+1] * pSrcReal[n];  
00050  * }  
00051  * </pre>  
00052  *  
00053  * There are separate functions for floating-point, Q15, and Q31 data types.  
00054  */ 
00055  
00056 /**  
00057  * @addtogroup CmplxByRealMult  
00058  * @{  
00059  */ 
00060  
00061  
00062 /**  
00063  * @brief  Floating-point complex-by-real multiplication  
00064  * @param[in]  *pSrcCmplx points to the complex input vector  
00065  * @param[in]  *pSrcReal points to the real input vector  
00066  * @param[out]  *pCmplxDst points to the complex output vector  
00067  * @param[in]  numSamples number of samples in each vector  
00068  * @return none.  
00069  */ 
00070  
00071 void arm_cmplx_mult_real_f32( 
00072   float32_t * pSrcCmplx, 
00073   float32_t * pSrcReal, 
00074   float32_t * pCmplxDst, 
00075   uint32_t numSamples) 
00076 { 
00077   float32_t in;                                  /* Temporary variable to store input value */ 
00078   uint32_t blkCnt;                               /* loop counters */ 
00079  
00080   /* loop Unrolling */ 
00081   blkCnt = numSamples >> 2u; 
00082  
00083   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.  
00084    ** a second loop below computes the remaining 1 to 3 samples. */ 
00085   while(blkCnt > 0u) 
00086   { 
00087     /* C[2 * i] = A[2 * i] * B[i].            */ 
00088     /* C[2 * i + 1] = A[2 * i + 1] * B[i].        */ 
00089     in = *pSrcReal++; 
00090     /* store the result in the destination buffer. */ 
00091     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00092     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00093  
00094     in = *pSrcReal++; 
00095     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00096     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00097  
00098     in = *pSrcReal++; 
00099     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00100     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00101  
00102     in = *pSrcReal++; 
00103     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00104     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00105  
00106     /* Decrement the numSamples loop counter */ 
00107     blkCnt--; 
00108   } 
00109  
00110   /* If the numSamples is not a multiple of 4, compute any remaining output samples here.  
00111    ** No loop unrolling is used. */ 
00112   blkCnt = numSamples % 0x4u; 
00113  
00114   while(blkCnt > 0u) 
00115   { 
00116     /* C[2 * i] = A[2 * i] * B[i].            */ 
00117     /* C[2 * i + 1] = A[2 * i + 1] * B[i].        */ 
00118     in = *pSrcReal++; 
00119     /* store the result in the destination buffer. */ 
00120     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00121     *pCmplxDst++ = (*pSrcCmplx++) * (in); 
00122  
00123     /* Decrement the numSamples loop counter */ 
00124     blkCnt--; 
00125   } 
00126 } 
00127  
00128 /**  
00129  * @} end of CmplxByRealMult group  
00130  */