arm_mat_mult_f32.c

Go to the documentation of this file.

/* ----------------------------------------------------------------------      
* Copyright (C) 2011 ARM Limited. All rights reserved. 
*      
* $Date:        15. December 2011   
* $Revision:    V2.0.0  
*      
* Project:      Cortex-R DSP Library 
* Title:        arm_mat_mult_f32.c      
*      
* Description:  Floating-point matrix multiplication.      
*      
* Target Processor:          Cortex-R4/R5
*
* Version 1.0.0 2011/03/08
*     Alpha release.
*
* Version 1.0.1 2011/09/30
*     Beta release.
*
* Version 2.0.0 2011/12/15
*     Final release. 
* 
* -------------------------------------------------------------------- */     
     
#include "arm_math.h"     
     
arm_status arm_mat_mult_f32(     
  const arm_matrix_instance_f32 * pSrcA,     
  const arm_matrix_instance_f32 * pSrcB,     
  arm_matrix_instance_f32 * pDst)     
{     
  float32_t *pIn1 = pSrcA->pData;                /* input data matrix pointer A */     
  float32_t *pIn2 = pSrcB->pData;                /* input data matrix pointer B */     
  float32_t *pInA = pSrcA->pData;                /* input data matrix pointer A  */     
  float32_t *pOut = pDst->pData;                 /* output data matrix pointer */     
  float32_t *px;                                 /* Temporary output data matrix pointer */     
  float32_t sum;                                 /* Accumulator */     
  float32_t in1, in2, in3, in4;                  /* Temporary variables */   
  uint16_t numRowsA = pSrcA->numRows;            /* number of rows of input matrix A */     
  uint16_t numColsB = pSrcB->numCols;            /* number of columns of input matrix B */     
  uint16_t numColsA = pSrcA->numCols;            /* number of columns of input matrix A */     
  uint16_t col, i = 0u, j, row = numRowsA, colCnt;      /* loop counters */     
  arm_status status;                             /* status of matrix multiplication */     
     
#ifdef ARM_MATH_MATRIX_CHECK     
  /* Check for matrix mismatch condition */     
  if((pSrcA->numCols != pSrcB->numRows) ||     
     (pSrcA->numRows != pDst->numRows) || (pSrcB->numCols != pDst->numCols))     
  {     
     
    /* Set status as ARM_MATH_SIZE_MISMATCH */     
    status = ARM_MATH_SIZE_MISMATCH;     
  }     
  else     
#endif     
  {     
    /* The following loop performs the dot-product of each row in pSrcA with each column in pSrcB */     
    /* row loop */     
    do     
    {     
      /* Output pointer is set to starting address of the row being processed */     
      px = pOut + i;     
     
      /* For every row wise process, the column loop counter is to be initiated */     
      col = numColsB;     
     
      /* For every row wise process, the pIn2 pointer is set      
       ** to the starting address of the pSrcB data */     
      pIn2 = pSrcB->pData;     
     
      j = 0u;     
     
      /* column loop */     
      do     
      {     
        /* Set the variable sum, that acts as accumulator, to zero */     
        sum = 0.0f;     
     
        /* Initiate the pointer pIn1 to point to the starting address of the column being processed */     
        pIn1 = pInA;     
     
        /* Apply loop unrolling and compute 4 MACs simultaneously. */     
        colCnt = numColsA >> 2u;     
     
        /* matrix multiplication        */     
        while(colCnt > 0u)     
        {     
          /* c(m,n) = a(1,1)*b(1,1) + a(1,2) * b(2,1) + .... + a(m,p)*b(p,n) */     
          in3 = *pIn2;  
          pIn2 += numColsB;  
          in1 = pIn1[0];   
          in2 = pIn1[1];   
          sum += in1 * in3;     
          in4 = *pIn2;  
          pIn2 += numColsB;   
          sum += in2 * in4;     
   
          in3 = *pIn2;  
          pIn2 += numColsB;  
          in1 = pIn1[2];   
          in2 = pIn1[3];   
          sum += in1 * in3;     
          in4 = *pIn2;  
          pIn2 += numColsB;   
          sum += in2 * in4;     
          pIn1 += 4u;  
     
          /* Decrement the loop count */     
          colCnt--;     
        }     
     
        /* If the columns of pSrcA is not a multiple of 4, compute any remaining MACs here.      
         ** No loop unrolling is used. */     
        colCnt = numColsA % 0x4u;     
     
        while(colCnt > 0u)     
        {     
          /* c(m,n) = a(1,1)*b(1,1) + a(1,2) * b(2,1) + .... + a(m,p)*b(p,n) */     
          sum += *pIn1++ * (*pIn2);     
          pIn2 += numColsB;     
     
          /* Decrement the loop counter */     
          colCnt--;     
        }     
     
        /* Store the result in the destination buffer */     
        *px++ = sum;     
     
        /* Update the pointer pIn2 to point to the  starting address of the next column */     
        j++;     
        pIn2 = pSrcB->pData + j;     
     
        /* Decrement the column loop counter */     
        col--;     
     
      } while(col > 0u);     
     
      /* Update the pointer pInA to point to the  starting address of the next row */     
      i = i + numColsB;     
      pInA = pInA + numColsA;     
     
      /* Decrement the row loop counter */     
      row--;     
     
    } while(row > 0u);     
     
    /* Set status as ARM_MATH_SUCCESS */     
    status = ARM_MATH_SUCCESS;     
  }     
     
  /* Return to application */     
  return (status);     
}