IntArray.h

Go to the documentation of this file.

#ifndef __IntArray_h__
#define __IntArray_h__
 
#include <stdint.h>
#include "SimpleArray.h"
#include "FloatArray.h"
#include <limits.h>
 
class IntArray : public SimpleArray<int32_t> {
public:
  IntArray(){}
  IntArray(int32_t* data, size_t size) :
    SimpleArray(data, size) {}
 
  void setAll(int32_t value){
  #ifdef ARM_CORTEX
    arm_fill_q31(value, data, size);
  #else
    for(size_t n=0; n<size; n++){
      data[n]=value;
    }
  #endif /* ARM_CORTEX */
  }
 
  void clear(){
    setAll(0);
  }
  
  void add(IntArray operand2, IntArray destination){ //allows in-place
    //ASSERT(operand2.size >= size &&  destination.size<=size, "Arrays must be matching size");
  #ifdef ARM_CORTEX
    arm_add_q31(data, operand2.data, destination.data, size);
  #else
    for(size_t n=0; n<size; n++){
      destination[n]=data[n]+operand2[n];
    }
  #endif /* ARM_CORTEX */
}
  
  void add(IntArray operand2){ //in-place
    add(operand2, *this);
  } //in-place
 
  void shift(int shiftValue){
#ifdef ARM_CORTEX
    arm_shift_q31(data, shiftValue, data, size);
#else
    if(shiftValue >= 0){
      for(size_t n=0; n<size; n++)
    data[n] = data[n] << shiftValue;
    }else{
      shiftValue = -shiftValue;
      for(size_t n=0; n<size; n++)
    data[n] = data[n] >> shiftValue;
    }
#endif
  }
 
  IntArray subArray(int offset, size_t length){
    ASSERT(size >= offset+length, "Array too small");
    return IntArray(data+offset, length);
  }
 
 
  void toFloat(FloatArray destination){
    ASSERT(destination.getSize() == size, "Size does not match");
#ifdef ARM_CORTEX
    arm_q31_to_float(data, destination.getData(), size);
#else
    for(size_t n = 0; n < size; ++n)
      destination[n] = getFloatValue(n);
#endif
  }
 
  void fromFloat(FloatArray source){
    ASSERT(source.getSize() == size, "Size does not match");
#ifdef ARM_CORTEX
    arm_float_to_q31(source.getData(), data, size);
#else
    for(size_t n = 0; n < size; ++n){
      setFloatValue(n, source[n]);
    }
#endif
  }
 
  void setFloatValue(uint32_t n, float value){
    data[n] = (int32_t)(value * -(float)INT_MIN);
  }
 
  float getFloatValue(uint32_t n){
    return data[n] / -(float)INT_MIN;
  }
 
  static IntArray create(int size){
    IntArray fa(new int32_t[size], size);
    fa.clear();
    return fa;
  }
  
  static void destroy(IntArray array){
    delete[] array.data;
  }
};
 
#endif // __IntArray_h__