added add() and subtract()

Author: mars

LibSource/ComplexFloatArray.cpp

@@ -67,7 +67,7 @@ void ComplexFloatArray::complexDotProduct(ComplexFloatArray& operand2, ComplexFl
 }
 
 void ComplexFloatArray::complexByComplexMultiplication(ComplexFloatArray& operand2, ComplexFloatArray& result){
-  ASSERT(size==operand2.getSize(), "Wrong size");
+  ASSERT(operand2.size == size && result.size >= size, "Arrays size mismatch");
 /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
 #ifdef ARM_CORTEX
   arm_cmplx_mult_cmplx_f32( (float*)data, (float*)operand2, (float*)result, size );  
@@ -82,8 +82,40 @@ void ComplexFloatArray::complexByComplexMultiplication(ComplexFloatArray& operan
 #endif  
 }
 
+void ComplexFloatArray::add(ComplexFloatArray operand2, ComplexFloatArray destination){
+  ASSERT(operand2.size == size && destination.size >= size, "Arrays size mismatch");
+#ifdef ARM_CORTEX
+  arm_add_f32((float*)data, (float*)operand2.data, (float*)destination.data, size*2);
+#else
+  for(int n=0; n<size; n++){
+    destination[n].re = data[n].re + operand2[n].re;
+    destination[n].im = data[n].im + operand2[n].im;
+  }
+#endif /* ARM_CORTEX */  
+}
+
+void ComplexFloatArray::add(ComplexFloatArray operand2){
+  add(operand2, *this);
+}
+
+void ComplexFloatArray::subtract(ComplexFloatArray operand2, ComplexFloatArray destination){
+  ASSERT(operand2.size == size && destination.size >= size, "Arrays size mismatch");
+#ifdef ARM_CORTEX
+  arm_sub_f32((float*)data, (float*)operand2.data, (float*)destination.data, size*2);
+#else
+  for(int n=0; n<size; n++){
+    destination[n].re = data[n].re - operand2[n].re;
+    destination[n].im = data[n].im - operand2[n].im;
+  }
+#endif /* ARM_CORTEX */  
+}
+
+void ComplexFloatArray::subtract(ComplexFloatArray operand2){
+  subtract(operand2, *this);
+}
+
 void ComplexFloatArray::getComplexConjugateValues(ComplexFloatArray& destination){
-  ASSERT(size==destination.getSize(), "Wrong size");
+  ASSERT(size==destination.getSize(), "Wrong array size");
 /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
 #ifdef ARM_CORTEX
   arm_cmplx_conj_f32( (float*)data, (float*)destination, size );  
@@ -106,7 +138,7 @@ void ComplexFloatArray::complexByRealMultiplication(FloatArray& operand2, Comple
   float *pSrcCmplx=(float*)data;
   float *pSrcReal=(float*)operand2;
   float *pCmplxDst=(float*)result;
-  for(int n=0; n<size; n++) {        
+  for(int n=0; n<size; n++) {
       pCmplxDst[(2*n)+0] = pSrcCmplx[(2*n)+0] * pSrcReal[n];        
       pCmplxDst[(2*n)+1] = pSrcCmplx[(2*n)+1] * pSrcReal[n];        
   }        

LibSource/ComplexFloatArray.h

@@ -163,6 +163,37 @@ class ComplexFloatArray {
     @param[out] result The array where the result of the multiplication is stored 
   */ 
   void complexByRealMultiplication(FloatArray& operand2, ComplexFloatArray& result);
+
+  /**
+   * Element-wise sum between complex arrays.
+   * Sets each element in **destination** to the complex sum of the corresponding element of the array and **operand2**
+   * @param[in] operand2 second operand for the sum
+   * @param[out] destination the destination array
+  */
+  void add(ComplexFloatArray operand2, ComplexFloatArray destination);
+
+  /**
+   * In-place element-wise sum between complex arrays.
+   * Adds each element of **operand2** to the corresponding element in the array.
+   * @param operand2 second operand for the sum
+  */
+  void add(ComplexFloatArray operand2);
+
+  /**
+   * Element-wise difference between complex arrays.
+   * Sets each element in **destination** to the complex difference between the corresponding element of the array and **operand2**
+   * @param[in] operand2 second operand for the subtraction
+   * @param[out] destination the destination array
+  */
+  void subtract(ComplexFloatArray operand2, ComplexFloatArray destination);
+
+  /**
+   * In-place element-wise difference between complex arrays.
+   * Sutracts each element of **operand2** from the corresponding element in the array.
+   * @param operand2 second operand for the sum
+  */
+  void subtract(ComplexFloatArray operand2);
+
   int getSize() const{
     return size;
   }
@@ -183,8 +214,8 @@ class ComplexFloatArray {
    * A subset of the array.
    * Returns an array that points to subset of the memory used by the original array.
    * @param[in] offset the first element of the subset.
-   * @param[in] length the number of elments in the new FloatArray.
-   * @return the newly created FloatArray.
+   * @param[in] length the number of elments in the new ComplexFloatArray.
+   * @return the newly created ComplexFloatArray.
    * @remarks no memory is allocated by this method. The memory is still shared with the original array.
    * The memory should not be de-allocated elsewhere (e.g.: by calling ComplexFloatArray::destroy() on the original ComplexFloatArray) 
    * as long as the ComplexFloatArray returned by this method is still in use.

LibSource/FloatArray.cpp

@@ -212,9 +212,11 @@ void FloatArray::scale(float factor){
 /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
   scale(factor, *this);
 }
+
 void FloatArray::clip(){
   clip(1);
 }
+
 void FloatArray::clip(float max){
   for(int n=0; n<size; n++){
     if(data[n]>max)
@@ -326,7 +328,7 @@ void FloatArray::add(float scalar){
 }
 
 void FloatArray::subtract(FloatArray operand2, FloatArray destination){ //allows in-place
-  ASSERT(operand2.size == size && destination.size==size, "Arrays must be same size");
+  ASSERT(operand2.size == size && destination.size >= size, "Arrays size mismatch");
   /// @note When built for ARM Cortex-M processor series, this method uses the optimized <a href="http://www.keil.com/pack/doc/CMSIS/General/html/index.html">CMSIS library</a>
 #ifdef ARM_CORTEX
   /* despite not explicitely documented in the CMSIS documentation,