---

Float4Vector.hpp

#ifndef __Float4Vector_H__
#define __Float4Vector_H__



#include <stdio.h>
#include <math.h>

#include "sseUtil.h"


class Float4Vector
{
private:
        

int             dataSize4;
int             dataSize;

float*  palign;

float*  data;
float*  data1;

public:
        
Float4Vector(int size);
Float4Vector(int size, float adata);
Float4Vector(const Float4Vector& v);
Float4Vector operator=(const Float4Vector& v);

~Float4Vector(){ data=0; delete data1; delete[] palign; }


inline int size(){ return dataSize; }
inline int sizeData(){ return dataSize4; }

void load(Float4Vector* v);

inline float* getData(){return data;}

inline float* get0(){return data;}
inline float* get(){return data1;}

// base 0
inline void set0(int line, int index, float value){ data[(index << 2)+line]= value; }
inline float get0(int line, int index){ return data[(index << 2)+line]; }

// base 1
inline void set(int line, int index, float value){ data1[(index << 2)+line]= value; }
inline float get(int line, int index){ return data1[(index << 2)+line]; }

void setAll(float value);

// computations
float vT_v(int line);
float norme2(int line);
float sum(int line);

float minimum(int line);
float maximum(int line);
float mean(int line){ return sum(line)/dataSize; }
float sigma(int line);


inline SSE4 vT_v()
        {
        SSE4 val;
        xorps_r2r(xmm0, xmm0);                          // 0
        
        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);               // get 4 data
                mulps_r2r(xmm1, xmm1);                  // sqr
                addps_r2r(xmm1, xmm0);                  // sum of sqr
                }

        movaps_r2m(xmm0, val.m);                        // get 4 sum of square in one

        return val;
        }

inline SSE4 norme2()
        {
        SSE4 val;
        xorps_r2r(xmm0, xmm0);                          // 0

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i], xmm1);              // get 4 data

                mulps_r2r(xmm1, xmm1);                  // sqr
                addps_r2r(xmm1, xmm0);                  // sum of sqr
                }

        sqrtps_r2r(xmm0,xmm0);                          // norme 2
        movaps_r2m(xmm0, val.m);                        // get 4 results

        return val;
        }

inline SSE4 sum()
        {
        SSE4 val;
        xorps_r2r(xmm0, xmm0);                          // 0
        

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);               // get 4 data
                addps_r2r(xmm1, xmm0);                  // sum 
                }

        movaps_r2m(xmm0, val.m);                        // get 4 sum 

        return val;
        }

inline SSE4 minimum()
        {
        SSE4 val;
        movaps_m2r(data[0], xmm0);                              

        for(int i=4; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);               // get 4 data
                minps_r2r(xmm1, xmm0);                  // min 
                }

        movaps_r2m(xmm0, val.m);                        // get result

        return val;
        }

inline SSE4 maximum()
        {
        SSE4 val;
        movaps_m2r(data[0], xmm0);                              

        for(int i=4; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);               // get 4 data
                maxps_r2r(xmm1, xmm0);                  // min 
                }

        movaps_r2m(xmm0, val.m);                        // get result

        return val;
        }

inline SSE4 mean()
        {
        SSE4 val;
        xorps_r2r(xmm0, xmm0);                          // EX

        val.f[0]= dataSize;
        val.f[1]= dataSize;
        val.f[2]= dataSize;
        val.f[3]= dataSize;
        movaps_m2r(val.m, xmm4);

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm2);               // get 4 data  x

                addps_r2r(xmm2, xmm0);                  // sum
                }

        divps_r2r(xmm4, xmm0);                          // EX
        
        movaps_r2m(xmm0, val.m);                        // get 4 sum of square in one

        return val;
        }

inline SSE4 sigma()
        {
        SSE4 val;
        xorps_r2r(xmm0, xmm0);                          // EX
        xorps_r2r(xmm1, xmm1);                          // EX2  

        val.f[0]= dataSize;
        val.f[1]= dataSize;
        val.f[2]= dataSize;
        val.f[3]= dataSize;
        movaps_m2r(val.m, xmm4);

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm2);               // get 4 data  x
                
                movaps_r2r(xmm2, xmm3);
                mulps_r2r(xmm2, xmm3);                  // x2

                addps_r2r(xmm2, xmm0);                  // sum
                addps_r2r(xmm3, xmm1);                  // sum of sqr
                }

        divps_r2r(xmm4, xmm0);          // EX
        divps_r2r(xmm4, xmm1);          // EX2

        mulps_r2r(xmm0, xmm0);          // EX
        subps_r2r(xmm0, xmm0);
        sqrtps_r2r(xmm0,xmm0);          // 4 sigma
        
        movaps_r2m(xmm0, val.m);                        // get 4 sum of square in one

        return val;
        }


// math vectorial op
Float4Vector sqrt()
        {
        Float4Vector v(dataSize);

#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        v.set0(line, i, ::sqrt(data[(i << 2)+line]) );
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);
                sqrtps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, vdata[i]);
                }
#endif

        return v;
        }

Float4Vector pow(float pow);

Float4Vector sqr()
        {
        Float4Vector v(dataSize);

#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        v.set0(line, i, data[(i << 2)+line]*data[(i << 2)+line] );
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i],xmm1);
                movaps_r2r(xmm1, xmm0);
                mulps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, vdata[i]);
                }
#endif

        return v;
        }

Float4Vector exp();
Float4Vector log();
Float4Vector log(float base);

Float4Vector sin();
Float4Vector cos();
Float4Vector tan();


// vector single operations
void operator+=(Float4Vector& v)
        {
#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        data[(i << 2)+line] += v.get0(line,i);
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i], xmm0);
                movaps_m2r(vdata[i],xmm1);
                addps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, data[i]);
                }
#endif
        }

void operator-=(Float4Vector& v)
        {
#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        data[(i << 2)+line] -= v.get0(line,i);
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i], xmm0);
                movaps_m2r(vdata[i],xmm1);
                subps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, data[i]);
                }
#endif
        }

void operator*=(Float4Vector& v)
        {
#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        data[(i << 2)+line] *= v.get0(line,i);
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i], xmm0);
                movaps_m2r(vdata[i],xmm1);
                mulps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, data[i]);
                }
#endif
        }

void operator/=(Float4Vector& v)
        {
#ifndef SSE_USED
        for(int i=0; i<dataSize; i++)
                for(int line=0; line<4; line++)
                        data[(i << 2)+line] /= v.get0(line,i);
#else
        float* vdata= v.getData();

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(data[i], xmm0);
                movaps_m2r(vdata[i],xmm1);
                divps_r2r(xmm1, xmm0);
                movaps_r2m(xmm0, data[i]);
                }
#endif
        }

// friends

friend Float4Vector operator+(Float4Vector& v, float a);                        // v<op>a
friend Float4Vector operator+(float a, Float4Vector& v);                        // a<op>v
friend Float4Vector operator-(Float4Vector& v, float a);                        // v<op>a
friend Float4Vector operator-(float a, Float4Vector& v);                        // a<op>v
friend Float4Vector operator*(Float4Vector& v, float a);                        // v<op>a
friend Float4Vector operator*(float a, Float4Vector& v);                        // a<op>v
friend Float4Vector operator/(Float4Vector& v, float a);                        // v<op>a

friend Float4Vector operator+(Float4Vector& v1, Float4Vector& v2);                      // v1<op>v2
friend Float4Vector operator-(Float4Vector& v1, Float4Vector& v2);                      // v1<op>v2
        
void output();
void output(FILE* file);
};

/*
static inline void Float4Vector_c_norme2_4(float* dataIn, int dataSize4, float** val)
        {
        xorps_r2r(xmm0, xmm0);                          // 0

        for(int i=0; i<dataSize4; i+=4)
                {
                movaps_m2r(dataIn[i], xmm1);            // get 4 data

//              mulps_r2r(xmm1, xmm1);                  // sqr
                addps_r2r(xmm1, xmm0);                  // sum of sqr
                }

//      sqrtps_r2r(xmm0,xmm0);                          // norme 2
//      movaps_r2m(xmm0, *val[0]);                      // get 4 sum of square in one
        }
*/
#endif

         

Restoreinpaint sourceforge project `C++/Java Image Processing, Restoration, Inpainting Project'.

Bernard De Cuyper: Open Project Leader: Concept, design and development. Bernard De Cuyper & Eddy Fraiha 2002, 2003. Bernard De Cuyper 2004. Open and free, for friendly usage only. Modifications on Belgium ground of this piece of artistic work, by governement institutions or companies, must be notified to Bernard De Cuyper.