ComplexFloatArray.h

Go to the documentation of this file.

#ifndef __ComplexFloatArray_h__
#define __ComplexFloatArray_h__
 
#include "FloatArray.h"
#include "basicmaths.h"
 
struct ComplexFloat {
  constexpr ComplexFloat() : re(0), im(0) {}
  constexpr ComplexFloat(float x) : re(x), im(0) {}
  constexpr ComplexFloat(float re, float im) : re(re), im(im) {}
 
  float re;
  
  float im;
  
  float getMagnitude() const{
    return sqrtf(re*re+im*im);  
  }
  
  float getMagnitudeSquared() const{
    return re*re+im*im;  
  }
  
  float getPhase() const{
    return atan2f(im,re);
  }
  
  void setPhase(float phase){
    float magnitude = getMagnitude();
    setPolar(magnitude, phase);
  }
  
  void setMagnitude(float magnitude){
    float phase = getPhase();
    setPolar(magnitude, phase);
  }  
  
  void setPolar(float magnitude, float phase){
    re = magnitude*cosf(phase);
    im = magnitude*sinf(phase);
  }
 
  ComplexFloat getComplexConjugate() const {
    return ComplexFloat {re, -im};
  }
 
  ComplexFloat getDotProduct(ComplexFloat other) const {
    return ComplexFloat {re * other.re - im  * other.im, re * other.im + im * other.re};
  }
 
  bool operator<(const ComplexFloat& other) const {
    return getMagnitudeSquared() < other.getMagnitudeSquared();
  }
 
  bool operator>(const ComplexFloat& other) const {
    return getMagnitudeSquared() > other.getMagnitudeSquared();
  }
 
  bool operator<=(const ComplexFloat& other) const {
    return getMagnitudeSquared() <= other.getMagnitudeSquared();
  }
 
  bool operator>=(const ComplexFloat& other) const {
    return getMagnitudeSquared() >= other.getMagnitudeSquared();
  }
 
  bool operator==(const ComplexFloat& other) const {
    return re == other.re && im == other.im;
  }
  
  bool operator!=(const ComplexFloat& other) const {
    return re != other.re || im != other.im;
  }
 
  friend const ComplexFloat operator+(const ComplexFloat&lhs, const ComplexFloat& rhs) {
    ComplexFloat result = lhs;
    result += rhs;
    return result;
  }
 
  friend const ComplexFloat operator+(const ComplexFloat&lhs, float rhs) {
    ComplexFloat result = lhs;
    result += rhs;
    return result;
  }
 
  ComplexFloat& operator+=(float other) {
    re += other;
    return *this;
  }
 
  ComplexFloat& operator+=(const ComplexFloat& other) {
    re += other.re;
    im += other.im;
    return *this;
  }
 
  friend const ComplexFloat operator-(const ComplexFloat&lhs, const ComplexFloat& rhs) {
    ComplexFloat result = lhs;
    result -= rhs;
    return result;
  }
 
  friend const ComplexFloat operator-(const ComplexFloat&lhs, float rhs) {
    ComplexFloat result = lhs;
    result -= rhs;
    return result;
  }
 
  ComplexFloat& operator-=(float other) {
    re -= other;
    return *this;
  }
 
  ComplexFloat& operator-=(const ComplexFloat& other) {
    re -= other.re;
    im -= other.im;
    return *this;
  }
 
  friend const ComplexFloat operator*(const ComplexFloat&lhs, const ComplexFloat& rhs) {
    ComplexFloat result = lhs;
    result *= rhs;
    return result;
  }
 
  friend const ComplexFloat operator*(const ComplexFloat&lhs, float rhs) {
    ComplexFloat result = lhs;
    result *= rhs;
    return result;
  }
 
  ComplexFloat& operator*=(float other) {
    re *= other;
    im *= other;
    return *this;
  }
 
  ComplexFloat& operator*=(const ComplexFloat& other) {
    re = re * other.re - im * other.im;
    im = re * other.im + im * other.re;
    return *this;
  }
 
  friend const ComplexFloat operator/(const ComplexFloat&lhs, float rhs) {
    ComplexFloat result = lhs;
    result /= rhs;
    return result;
  }
 
  ComplexFloat& operator/=(float other) {
    re /= other;
    im /= other;
    return *this;
  }
 
};
 
class ComplexFloatArray : public SimpleArray<ComplexFloat> {
public:
  ComplexFloatArray(){}
  ComplexFloatArray(ComplexFloat* data, size_t size) :
    SimpleArray(data, size) {}
    
  float re(const int i){
    return data[i].re;
  }
  
  float im(const int i){
    return data[i].im;
  }
  
  void clear(){
    setAll(0);
  }
 
  float mag(const int i);
  
  void getMagnitudeValues(FloatArray destination);
  
  float mag2(const int i);
  
  void getMagnitudeSquaredValues(FloatArray destination);
  
  void getComplexConjugateValues(ComplexFloatArray destination);
  
  void complexDotProduct(ComplexFloatArray operand2, ComplexFloat& result);
 
  void complexByComplexMultiplication(ComplexFloatArray operand2, ComplexFloatArray result);
  
  void complexByRealMultiplication(FloatArray operand2, ComplexFloatArray result);
 
  void add(ComplexFloatArray operand2, ComplexFloatArray destination);
 
  void add(ComplexFloatArray operand2);
 
  void subtract(ComplexFloatArray operand2, ComplexFloatArray destination);
 
  void subtract(ComplexFloatArray operand2);
  
  float getMaxMagnitudeValue();
  
  int getMaxMagnitudeIndex();
  
  ComplexFloatArray subArray(int offset, size_t length);
  
  void getRealValues(FloatArray buf);
  
  void getImaginaryValues(FloatArray buf);
  
  void scale(float factor);
  
  static ComplexFloatArray create(size_t size);
 
  static void destroy(ComplexFloatArray);
 
  void fromFloat(FloatArray source);
  
  void toFloat(FloatArray destination);
 
  void setAll(ComplexFloat value);
  
  void setAll(float value);
  
  void setAll(float valueRe, float valueIm);
 
  void getPolar(FloatArray magnitude, FloatArray phase);
 
  void setPolar(FloatArray magnitude, FloatArray phase);
  
  void setPolar(FloatArray magnitude, FloatArray phase, int offset, size_t count);
    
  void getPhaseValues(FloatArray destination);
 
  void setPhase(FloatArray phase);
 
  void setPhase(FloatArray phase, int offset, size_t count);
  
  void setPhase(FloatArray phase, ComplexFloatArray destination);
  
  void setPhase(FloatArray phase, int offset, size_t count, ComplexFloatArray destination);
 
 
  void setMagnitude(FloatArray magnitude);
 
  void setMagnitude(FloatArray magnitude, int offset, size_t count);
  
  void setMagnitude(FloatArray magnitude, ComplexFloatArray destination);
  
  void setMagnitude(FloatArray magnitude, int offset, size_t count, ComplexFloatArray destination);
 
  using SimpleArray<ComplexFloat>::copyFrom;
  using SimpleArray<ComplexFloat>::copyTo;
  void copyFrom(FloatArray real, FloatArray imag);
 
  void copyTo(FloatArray real, FloatArray imag);
};
 
#endif // __ComplexFloatArray_h__