lib/main/CMSIS/DSP/Source/BasicMathFunctions/arm_offset_f32.c

   1 /* ----------------------------------------------------------------------
   2  * Project:      CMSIS DSP Library
   3  * Title:        arm_offset_f32.c
   4  * Description:  Floating-point vector offset
   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 groupMath
  33  */
  34
  35 /**
  36  * @defgroup offset Vector Offset
  37  *
  38  * Adds a constant offset to each element of a vector.
  39  *
  40  * <pre>
  41  *     pDst[n] = pSrc[n] + offset,   0 <= n < blockSize.
  42  * </pre>
  43  *
  44  * The functions support in-place computation allowing the source and
  45  * destination pointers to reference the same memory buffer.
  46  * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
  47  */
  48
  49 /**
  50  * @addtogroup offset
  51  * @{
  52  */
  53
  54 /**
  55  * @brief  Adds a constant offset to a floating-point vector.
  56  * @param[in]  *pSrc points to the input vector
  57  * @param[in]  offset is the offset to be added
  58  * @param[out]  *pDst points to the output vector
  59  * @param[in]  blockSize number of samples in the vector
  60  * @return none.
  61  */
  62
  63
  64 void arm_offset_f32(
  65   float32_t * pSrc,
  66   float32_t offset,
  67   float32_t * pDst,
  68   uint32_t blockSize)
  69 {
  70   uint32_t blkCnt;                               /* loop counter */
  71
  72 #if defined (ARM_MATH_DSP)
  73
  74 /* Run the below code for Cortex-M4 and Cortex-M3 */
  75   float32_t in1, in2, in3, in4;
  76
  77   /*loop Unrolling */
  78   blkCnt = blockSize >> 2U;
  79
  80   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.
  81    ** a second loop below computes the remaining 1 to 3 samples. */
  82   while (blkCnt > 0U)
  83   {
  84     /* C = A + offset */
  85     /* Add offset and then store the results in the destination buffer. */
  86     /* read samples from source */
  87     in1 = *pSrc;
  88     in2 = *(pSrc + 1);
  89
  90     /* add offset to input */
  91     in1 = in1 + offset;
  92
  93     /* read samples from source */
  94     in3 = *(pSrc + 2);
  95
  96     /* add offset to input */
  97     in2 = in2 + offset;
  98
  99     /* read samples from source */
 100     in4 = *(pSrc + 3);
 101
 102     /* add offset to input */
 103     in3 = in3 + offset;
 104
 105     /* store result to destination */
 106     *pDst = in1;
 107
 108     /* add offset to input */
 109     in4 = in4 + offset;
 110
 111     /* store result to destination */
 112     *(pDst + 1) = in2;
 113
 114     /* store result to destination */
 115     *(pDst + 2) = in3;
 116
 117     /* store result to destination */
 118     *(pDst + 3) = in4;
 119
 120     /* update pointers to process next samples */
 121     pSrc += 4U;
 122     pDst += 4U;
 123
 124     /* Decrement the loop counter */
 125     blkCnt--;
 126   }
 127
 128   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
 129    ** No loop unrolling is used. */
 130   blkCnt = blockSize % 0x4U;
 131
 132 #else
 133
 134   /* Run the below code for Cortex-M0 */
 135
 136   /* Initialize blkCnt with number of samples */
 137   blkCnt = blockSize;
 138
 139 #endif /* #if defined (ARM_MATH_DSP) */
 140
 141   while (blkCnt > 0U)
 142   {
 143     /* C = A + offset */
 144     /* Add offset and then store the result in the destination buffer. */
 145     *pDst++ = (*pSrc++) + offset;
 146
 147     /* Decrement the loop counter */
 148     blkCnt--;
 149   }
 150 }
 151
 152 /**
 153  * @} end of offset group
 154  */