Subversion Repositories complexarithmetic

#include <systemc.h>

#ifndef _CPLXOPSPHASOR_H_

#define _CPLXOPSPHASOR_H_

template<typename T>

class complex

{

    T real, imag;

    /*initialization of the real and imaginal parts of the complex values as 0

    definition of copy constructor and assignment operator*/

public:

    complex() : real(0),imag(0)

    {

    }

    complex( const T& real_, const T& imag_ ) : real(real_), imag(imag_){}

    complex( const complex& other ) : real(other.real), imag(other.imag){}

    complex& operator = ( const complex& other )

    {

        real = other.real;

        imag = other.imag;

        return *this;

    }

    /*definiton of mutators and access member functions*/

    T get_real() const

    {

        return real;

    }

    T get_imag() const

    {

        return imag;

    }

    void set_real( const T& real_ )

    {

        real = real_;

    }

    void set_imag( const T& imag_ )

    {

        imag = imag_;

    }

    /*Definition of member operators*/

    complex& operator += ( const complex& other )

    {

        real += other.real;

        imag += other.imag;

        return *this;

    }

    /*Definition of complex aritmetic operators as friend Operators.*/

    friend complex operator + ( const complex& a, const complex& b )  //approved

    {

        complex result;

        result.set_real( a.get_real() + b.get_real() );

        result.set_imag( a.get_imag() + b.get_imag() );

        return result;

    }

    friend complex operator * ( const complex& a, const complex& b )  //approved

    {

        complex result;

        sc_uint<8> areal, aimag, breal, bimag;       //real and imaginary parts of the operands

        sc_uint<16> tempreal,tempimag;               //temporary outputs (16 BITS)

        /*complex multiplication of two complex numnbers a and b is defined by

        a*b=(areal*breal-aimag*bimag)+i(areal*bimag+aimag*breal)*/

        areal=a.get_real();aimag=a.get_imag();

        breal=b.get_real();bimag=b.get_imag();

        tempreal=areal*breal-aimag*bimag;

        tempimag=aimag*breal+areal*bimag;

        result.set_real(tempreal);

        result.set_imag(tempimag);

        return result;                              //the result is returned

    }

    friend complex operator / ( const complex& a, const complex& b ) //approved

    {

        complex result;

        sc_uint<4> count=0;

        sc_uint<8> areal, aimag, breal, bimag;                                                   //real and imaginary parts of the operands

        sc_uint<8> tempxa=0,tempya=0,tempxb=0,tempyb=0,anglea=0,angleb=0,angleresult,rresult,angle=90,us=128;    //,raparameters to accumulate the temporary results of the operation

//        sc_uint<16> rb;

        areal=a.get_real(); breal=b.get_real(); aimag=a.get_imag(); b.get_imag();                       //read real and imaginary parts of the complex operands

        /*the operands will first be converted from cartesian to polar representation using cordic techniques

       then the operands will be divided as a/b=ra/rb(anglea-angleb) */

        if (areal[7]==1)                    //determination of the initial angular position of the operands

        {

            anglea=180;

        }

        if (breal[7]==1)

        {

            angleb=180;

        }

        while (count<=6)                    //CORDIC vector mode operation for converting 

        {                                   //the operands from cartesian to polar representation

            angle=angle>>1;

                        count++;

                        tempxa = areal>>count;

            tempya = aimag>>count;

            tempxb = breal>>count;

            tempyb = bimag>>count;

           if ( aimag[7]==1 )              //CORDIC operation for the first operand

            {

                areal=areal-tempya;

                aimag=aimag+tempxa;

                anglea=anglea-angle;

            }

            else //if ( aimag[7]==0 )

            {

                areal=areal+tempya;

                aimag=aimag-tempxa;

                anglea=anglea+angle;

           }

            if ( bimag[7]==0 )             //CORDIC operation for the second operand

            {

                breal=breal-tempyb;

                bimag=bimag+tempxb;

                angleb=angleb-angle;

            }

            else //if ( bimag[7]==0 )

            {

                breal=breal+tempyb;

                bimag=bimag-tempxb;

                angleb=angleb+angle;

           }

        }

        rresult=areal/breal;                      //divide the absolute values

        angleresult=anglea-angleb;          //subtract the polar angles

        count=0;

        sc_uint<8> y=0,tempr,tempy;

                angle=90;

        while (count<=6)                    //CORDIC vector mode operation for converting 

        {                                   //the result from polar to cartesian representation

            count++;

                        tempr = rresult>>count;

            tempy = y>>count;

            angle=angle>>1;

            if (angleresult[7]==0)

            {

                rresult=rresult-tempy;

                y=y+tempr;

                angleresult=angleresult-angle;

            }

            else if (angleresult[7]==1)

            {

                rresult=rresult+tempy;

                y=y-tempr;

                angleresult=angleresult+angle;

            }

         }

        result.set_real(rresult);

        result.set_imag(angleresult);

        return result;

   }

    friend complex pol2car ( const complex& a)//approved

    {

        complex result;

        sc_int <4> count=0;

        sc_uint <8> r,angle;                 //absolute value and polar angle of the operand

        sc_uint <8> tempr,tempy,tempangle=90,y; //temporary values for polar to cartesian operation

        r=a.get_real();

        angle=a.get_imag();

         while (count<6) //count= 1; count < 7; count++)  //Cordic operation for polar to cartesian transformation

        {

            count++;

                        tempr = r >>count;

            tempy = y >>count;

            tempangle=tempangle>>1;

            if (angle[7]==0)

            {

                r=r-tempy;

                y=y+tempr;

                angle=angle-tempangle;

            }

            else if (angle[7]==1)

            {

                r=r+tempy;

                y=y-tempr;

                angle=angle+tempangle;

            }

        }

        result.set_real(r);

        result.set_imag(y);

        return (result);

    }

    friend complex sqrt ( const complex& a)     //approved

    {    //sqrt(x+iy)==1/2sqrt(2)[sqrt(sqrt(x^2+y^2)+x)+isgn(y)sqrt(sqrt(x^2+y^2)-x)].

        complex result;

        int cnt=0;//,cnt1=1;

        sc_uint<8> tempabs, tempreal, tempimag, sgn, areal, aimag, abs, base1, base2, sqrt1,sqrt2;//ra,

        sc_uint<8> tempareal,tempaimag;

                areal=a.get_real();

        aimag=a.get_imag();

        abs=a.get_real();

        while (cnt<6)        //CORDIC vector mode to evaluate the absolute value of a

        {

            cnt++;

            tempareal = areal >>cnt;

            tempaimag = aimag >>cnt;

            if ( aimag[7]==1)

            {

                abs=abs-tempaimag;

                aimag=aimag+tempabs;

            }

            if ( aimag[7]==0)

            {

                abs=abs+tempaimag;

                aimag=aimag-tempabs;

            }

        }

        tempreal=abs+a.get_real();                  //sqrt(x^2+y^2)+x

        tempimag=abs-a.get_real();                  //sqrt(x^2+y^2)-x

        sqrt1=0;base1=8;sqrt2=0;base2=8;

        for (cnt= 0; cnt < 2; cnt++)//while (cnt1<5)                             //evaluating the temporary square roots using numeric techniques

        {                                           //sqrt(sqrt(x^2+y^2)+x),sqrt(sqrt(x^2+y^2)-x)

                 sqrt1 = base1 + sqrt1;

                if  ( (base1 * base1) > tempreal )

                {

                        sqrt1 = base1 - sqrt1 ;     // base should not have been added, so we substract again

                }

                base1>>1 ;                        // shift 1 digit to the right = divide baimag 2

                sqrt2 = base2 + sqrt2 ;

                if  ( (sqrt2 * sqrt2) > tempimag )

                {

                        sqrt2 = base2 - sqrt2 ;

                }

                base2>>1 ;

        }

        sqrt1=sqrt1>>1;                             //multiply the tmeporary results with 0.5 instead of 0.7

        sqrt2=sqrt2>>1;                             //1/2*sqrt(2)=

        sqrt2[7]=aimag[7];                          //apply the sign of the imaginary part

        result.set_real(sqrt1);

        result.set_imag(sqrt2);

        return result;

    }

    friend complex operator - ( const complex& a, const complex& b )//approved

    {

        complex result;

        result.set_real( a.get_real() - b.get_real() );

        result.set_imag( a.get_imag() - b.get_imag() );

        return result;

    }

    friend complex conj ( const complex& a )//approved

    {

        complex result;

                sc_uint<8> tempa,tempb;

                tempa=a.get_imag();

                tempb=tempa;

                tempb[7]=!tempa[7];

        result.set_real( a.get_real());

        result.set_imag( tempb);

        return result;

    }

    /*

     * Predicate operators

     */

    friend bool operator == ( const complex& a, const complex& b )

    {

        return ( (a.get_real() == b.get_real()) && (a.get_real() == b.get_real()) );

    }

    friend bool operator != ( const complex& a, const complex& b )

    {

        return ( ! (a == b) );

    }

};

#endif