Subversion Repositories dashGPS

Rev

Rev 2 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /* ----------------------------------------------------------------------
  2.  * Project:      CMSIS DSP Library
  3.  * Title:        arm_mat_cmplx_mult_f32.c
  4.  * Description:  Floating-point matrix multiplication
  5.  *
  6.  * $Date:        27. January 2017
  7.  * $Revision:    V.1.5.1
  8.  *
  9.  * Target Processor: Cortex-M cores
  10.  * -------------------------------------------------------------------- */
  11. /*
  12.  * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved.
  13.  *
  14.  * SPDX-License-Identifier: Apache-2.0
  15.  *
  16.  * Licensed under the Apache License, Version 2.0 (the License); you may
  17.  * not use this file except in compliance with the License.
  18.  * You may obtain a copy of the License at
  19.  *
  20.  * www.apache.org/licenses/LICENSE-2.0
  21.  *
  22.  * Unless required by applicable law or agreed to in writing, software
  23.  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  24.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  25.  * See the License for the specific language governing permissions and
  26.  * limitations under the License.
  27.  */
  28.  
  29. #include "arm_math.h"
  30.  
  31. /**
  32.  * @ingroup groupMatrix
  33.  */
  34.  
  35. /**
  36.  * @defgroup CmplxMatrixMult  Complex Matrix Multiplication
  37.  *
  38.  * Complex Matrix multiplication is only defined if the number of columns of the
  39.  * first matrix equals the number of rows of the second matrix.
  40.  * Multiplying an <code>M x N</code> matrix with an <code>N x P</code> matrix results
  41.  * in an <code>M x P</code> matrix.
  42.  * When matrix size checking is enabled, the functions check: (1) that the inner dimensions of
  43.  * <code>pSrcA</code> and <code>pSrcB</code> are equal; and (2) that the size of the output
  44.  * matrix equals the outer dimensions of <code>pSrcA</code> and <code>pSrcB</code>.
  45.  */
  46.  
  47.  
  48. /**
  49.  * @addtogroup CmplxMatrixMult
  50.  * @{
  51.  */
  52.  
  53. /**
  54.  * @brief Floating-point Complex matrix multiplication.
  55.  * @param[in]       *pSrcA points to the first input complex matrix structure
  56.  * @param[in]       *pSrcB points to the second input complex matrix structure
  57.  * @param[out]      *pDst points to output complex matrix structure
  58.  * @return              The function returns either
  59.  * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
  60.  */
  61.  
  62. arm_status arm_mat_cmplx_mult_f32(
  63.   const arm_matrix_instance_f32 * pSrcA,
  64.   const arm_matrix_instance_f32 * pSrcB,
  65.   arm_matrix_instance_f32 * pDst)
  66. {
  67.   float32_t *pIn1 = pSrcA->pData;                /* input data matrix pointer A */
  68.   float32_t *pIn2 = pSrcB->pData;                /* input data matrix pointer B */
  69.   float32_t *pInA = pSrcA->pData;                /* input data matrix pointer A  */
  70.   float32_t *pOut = pDst->pData;                 /* output data matrix pointer */
  71.   float32_t *px;                                 /* Temporary output data matrix pointer */
  72.   uint16_t numRowsA = pSrcA->numRows;            /* number of rows of input matrix A */
  73.   uint16_t numColsB = pSrcB->numCols;            /* number of columns of input matrix B */
  74.   uint16_t numColsA = pSrcA->numCols;            /* number of columns of input matrix A */
  75.   float32_t sumReal1, sumImag1;                  /* accumulator */
  76.   float32_t a0, b0, c0, d0;
  77.   float32_t a1, b1, c1, d1;
  78.   float32_t sumReal2, sumImag2;                  /* accumulator */
  79.  
  80.  
  81.   /* Run the below code for Cortex-M4 and Cortex-M3 */
  82.  
  83.   uint16_t col, i = 0U, j, row = numRowsA, colCnt;      /* loop counters */
  84.   arm_status status;                             /* status of matrix multiplication */
  85.  
  86. #ifdef ARM_MATH_MATRIX_CHECK
  87.  
  88.  
  89.   /* Check for matrix mismatch condition */
  90.   if ((pSrcA->numCols != pSrcB->numRows) ||
  91.      (pSrcA->numRows != pDst->numRows) || (pSrcB->numCols != pDst->numCols))
  92.   {
  93.  
  94.     /* Set status as ARM_MATH_SIZE_MISMATCH */
  95.     status = ARM_MATH_SIZE_MISMATCH;
  96.   }
  97.   else
  98. #endif /*      #ifdef ARM_MATH_MATRIX_CHECK    */
  99.  
  100.   {
  101.     /* The following loop performs the dot-product of each row in pSrcA with each column in pSrcB */
  102.     /* row loop */
  103.     do
  104.     {
  105.       /* Output pointer is set to starting address of the row being processed */
  106.       px = pOut + 2 * i;
  107.  
  108.       /* For every row wise process, the column loop counter is to be initiated */
  109.       col = numColsB;
  110.  
  111.       /* For every row wise process, the pIn2 pointer is set
  112.        ** to the starting address of the pSrcB data */
  113.       pIn2 = pSrcB->pData;
  114.  
  115.       j = 0U;
  116.  
  117.       /* column loop */
  118.       do
  119.       {
  120.         /* Set the variable sum, that acts as accumulator, to zero */
  121.         sumReal1 = 0.0f;
  122.         sumImag1 = 0.0f;
  123.  
  124.         sumReal2 = 0.0f;
  125.         sumImag2 = 0.0f;
  126.  
  127.         /* Initiate the pointer pIn1 to point to the starting address of the column being processed */
  128.         pIn1 = pInA;
  129.  
  130.         /* Apply loop unrolling and compute 4 MACs simultaneously. */
  131.         colCnt = numColsA >> 2;
  132.  
  133.         /* matrix multiplication        */
  134.         while (colCnt > 0U)
  135.         {
  136.  
  137.           /* Reading real part of complex matrix A */
  138.           a0 = *pIn1;
  139.  
  140.           /* Reading real part of complex matrix B */
  141.           c0 = *pIn2;
  142.  
  143.           /* Reading imaginary part of complex matrix A */
  144.           b0 = *(pIn1 + 1U);
  145.  
  146.           /* Reading imaginary part of complex matrix B */
  147.           d0 = *(pIn2 + 1U);
  148.  
  149.           sumReal1 += a0 * c0;
  150.           sumImag1 += b0 * c0;
  151.  
  152.           pIn1 += 2U;
  153.           pIn2 += 2 * numColsB;
  154.  
  155.           sumReal2 -= b0 * d0;
  156.           sumImag2 += a0 * d0;
  157.  
  158.           /* c(m,n) = a(1,1)*b(1,1) + a(1,2) * b(2,1) + .... + a(m,p)*b(p,n) */
  159.  
  160.           a1 = *pIn1;
  161.           c1 = *pIn2;
  162.  
  163.           b1 = *(pIn1 + 1U);
  164.           d1 = *(pIn2 + 1U);
  165.  
  166.           sumReal1 += a1 * c1;
  167.           sumImag1 += b1 * c1;
  168.  
  169.           pIn1 += 2U;
  170.           pIn2 += 2 * numColsB;
  171.  
  172.           sumReal2 -= b1 * d1;
  173.           sumImag2 += a1 * d1;
  174.  
  175.           a0 = *pIn1;
  176.           c0 = *pIn2;
  177.  
  178.           b0 = *(pIn1 + 1U);
  179.           d0 = *(pIn2 + 1U);
  180.  
  181.           sumReal1 += a0 * c0;
  182.           sumImag1 += b0 * c0;
  183.  
  184.           pIn1 += 2U;
  185.           pIn2 += 2 * numColsB;
  186.  
  187.           sumReal2 -= b0 * d0;
  188.           sumImag2 += a0 * d0;
  189.  
  190.           /* c(m,n) = a(1,1)*b(1,1) + a(1,2) * b(2,1) + .... + a(m,p)*b(p,n) */
  191.  
  192.           a1 = *pIn1;
  193.           c1 = *pIn2;
  194.  
  195.           b1 = *(pIn1 + 1U);
  196.           d1 = *(pIn2 + 1U);
  197.  
  198.           sumReal1 += a1 * c1;
  199.           sumImag1 += b1 * c1;
  200.  
  201.           pIn1 += 2U;
  202.           pIn2 += 2 * numColsB;
  203.  
  204.           sumReal2 -= b1 * d1;
  205.           sumImag2 += a1 * d1;
  206.  
  207.           /* Decrement the loop count */
  208.           colCnt--;
  209.         }
  210.  
  211.         /* If the columns of pSrcA is not a multiple of 4, compute any remaining MACs here.
  212.          ** No loop unrolling is used. */
  213.         colCnt = numColsA % 0x4U;
  214.  
  215.         while (colCnt > 0U)
  216.         {
  217.           /* c(m,n) = a(1,1)*b(1,1) + a(1,2) * b(2,1) + .... + a(m,p)*b(p,n) */
  218.           a1 = *pIn1;
  219.           c1 = *pIn2;
  220.  
  221.           b1 = *(pIn1 + 1U);
  222.           d1 = *(pIn2 + 1U);
  223.  
  224.           sumReal1 += a1 * c1;
  225.           sumImag1 += b1 * c1;
  226.  
  227.           pIn1 += 2U;
  228.           pIn2 += 2 * numColsB;
  229.  
  230.           sumReal2 -= b1 * d1;
  231.           sumImag2 += a1 * d1;
  232.  
  233.           /* Decrement the loop counter */
  234.           colCnt--;
  235.         }
  236.  
  237.         sumReal1 += sumReal2;
  238.         sumImag1 += sumImag2;
  239.  
  240.         /* Store the result in the destination buffer */
  241.         *px++ = sumReal1;
  242.         *px++ = sumImag1;
  243.  
  244.         /* Update the pointer pIn2 to point to the  starting address of the next column */
  245.         j++;
  246.         pIn2 = pSrcB->pData + 2U * j;
  247.  
  248.         /* Decrement the column loop counter */
  249.         col--;
  250.  
  251.       } while (col > 0U);
  252.  
  253.       /* Update the pointer pInA to point to the  starting address of the next row */
  254.       i = i + numColsB;
  255.       pInA = pInA + 2 * numColsA;
  256.  
  257.       /* Decrement the row loop counter */
  258.       row--;
  259.  
  260.     } while (row > 0U);
  261.  
  262.     /* Set status as ARM_MATH_SUCCESS */
  263.     status = ARM_MATH_SUCCESS;
  264.   }
  265.  
  266.   /* Return to application */
  267.   return (status);
  268. }
  269.  
  270. /**
  271.  * @} end of MatrixMult group
  272.  */
  273.