complexarray.h

Go to the documentation of this file.

#ifndef COMPLEX_ARRAY_H
#define COMPLEX_ARRAY_H
 
#include <complex>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cassert>
 
namespace ModuleBase
{
 
class ComplexArray
{
public:
    std::complex<double> *ptr=nullptr; // data array
    
    ComplexArray(const int bnd1=0, const int bnd2=1, const int bnd3=1, const int bnd4=1);
 
    ~ComplexArray();
 
    void freemem();
 
    void create(const int bnd1=0, const int bnd2=1, const int bnd3=1, const int bnd4=1);
 
    ComplexArray(const ComplexArray &cd);
    ComplexArray(ComplexArray &&cd);
 
    /****************************************************
    * OPERATOR FUNCTIONS
    ***************************************************/
    ComplexArray& operator=(ComplexArray &&cd);
    ComplexArray &operator=(const ComplexArray &cd);
    void operator=(std::complex <double> c);
    ComplexArray operator+(const ComplexArray &cd);
    void operator+=(const ComplexArray &cd);
    ComplexArray operator-(const ComplexArray &cd);
    void operator-=(const ComplexArray &cd);
    ComplexArray operator*(const double r);
    ComplexArray operator*(const std::complex <double> c);
    void operator*=(const double r);
    void operator*=(const std::complex <double> c);
    void operator*=(const ComplexArray &cd);
    bool operator== (const ComplexArray &cd2)const;
    bool operator!= (const ComplexArray &cd2)const;
 
    std::complex <double> &operator()
        (const int ind1=0, const int ind2=0, const int ind3=0, const int ind4=0)
        {
            assert(ind1>=0);    assert(ind1<bound1);
            assert(ind2>=0);    assert(ind2<bound2);
            assert(ind3>=0);    assert(ind3<bound3);
            assert(ind4>=0);    assert(ind4<bound4);
            const int ind = ((ind1 * bound2 + ind2) * bound3 + ind3) * bound4 + ind4;
            return ptr[ind];
        };
    //  std::complex < double> &operator()(int, int, int, int, int);
    const std::complex <double> &operator()
        (const int ind1=0, const int ind2=0, const int ind3=0, const int ind4=0) const
        {
            assert(ind1>=0);    assert(ind1<bound1);
            assert(ind2>=0);    assert(ind2<bound2);
            assert(ind3>=0);    assert(ind3<bound3);
            assert(ind4>=0);    assert(ind4<bound4);
            const int ind = ((ind1 * bound2 + ind2) * bound3 + ind3) * bound4 + ind4;
            return ptr[ind];
        };
    //  const std::complex < double> &operator()(int, int, int, int, int)const;
 
    /****************************************************
    * MEMBER FUNCTIONS
    ***************************************************/
    void zero_out(void);
 
    void negate(void);
 
    void randomize(void);
    int getBound1()const{ return bound1; }
    int getBound2()const{ return bound2; }
    int getBound3()const{ return bound3; }
    int getBound4()const{ return bound4; }
    int getSize()const{ return bound1*bound2*bound3*bound4; }
 
private:
    int bound1, bound2, bound3, bound4; 
    void init(const int size);
};
ComplexArray operator*(const double r, const ComplexArray &cd);
ComplexArray operator*(const std::complex <double> c, const ComplexArray &cd);
 
double abs2(const ComplexArray &cd);
 
// void add_scale_abs2(const std::complex <double> &c, const ComplexArray & in,
//                ComplexArray &out);
 
std::complex <double> dot(const ComplexArray &cd1, const ComplexArray &cd2);
 
void scale_accumulate(double r, const ComplexArray &cd1, ComplexArray &cd2);
 
void scale_accumulate(std::complex <double> c, const ComplexArray &cd1, ComplexArray &cd2);
 
void scaled_sum(double r1, const ComplexArray &cd1,
                double r2, const ComplexArray &cd2,
                ComplexArray &cd3);
 
void scaled_sum(std::complex <double> c1, const ComplexArray &cd1,
           std::complex <double> c2, const ComplexArray &cd2,
           ComplexArray &cd3);
 
void point_mult(ComplexArray &a1, ComplexArray &in2, ComplexArray &out);
 
template <class T>
void zeros(std::complex <T> *u, int n)
{
    if (n == 0 || u == 0)
    {
        std::cout << "\n error in zeros(),n or u = 0";
        return;
    }
 
    for (int i = 0;i < n;i++)
    {
        u[i] = std::complex <T> (0.0, 0.0);
    }
}
}
 
#endif // COMPLEX_ARRAY_H