---

FloatVector.hpp

#ifndef __FloatVector_H__
#define __FloatVector_H__



#include <stdio.h>

class FloatVectorT;
class AFSymMatrix;

class FloatVector
{
private:
        
int             dataSize;
float*  data;

float*  data1;

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

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

FloatVectorT t();

FloatVector* sub(int start, int step, int end);
FloatVector* copy();

inline int size(){ return dataSize; }

void load(FloatVector* v);
void load(float coeff, FloatVector* v);

float* getData(){return data;}

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

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

void setAll(float value);
void setAt(int p0, int n, float value);

// computations
int indexArgMin();
int indexArgMax();
float argMin();
float argMax();

float vT_v();
float norme1();
float norme2();
float normeInf(){ return argMax(); }
float sum();

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

void random(float minval=0.0, float maxval=1.0);

// differences
float undividedDiff(int cellj, int order);
float dividedDiff(int cellj, int order, float dx=1.0);

// math vectorial op
FloatVector sqrt();
FloatVector pow(float pow);
FloatVector sqr();
FloatVector exp();
FloatVector log();
FloatVector log(float base);

FloatVector sin();
FloatVector cos();
FloatVector tan();

// scalar single operations
void operator+=(float value);
void operator-=(float value);
void operator*=(float value);
void operator/=(float value);

// vector single operations
void operator+=(FloatVector& v);
void operator-=(FloatVector& v);
void operator*=(FloatVector& v);
void operator/=(FloatVector& v);

void subst(float a);                                                                    // x -= a
void mult(float a);                                                                     // x *= a
void div(float a);                                                                      // x /= a


void delta(FloatVector* v1, FloatVector* v);                                    // x = v1-v
void subst(FloatVector* v);                                                             // x -= v
void add(float a);                                                                      // x += a
void add(FloatVector* v);                                                               // x += v
void add(FloatVector* v, FloatVector* v1);                                      // x = v + v1
void add(FloatVector* v, FloatVector* v1, FloatVector* v2);                     // x = v + v1 + v2
void add(float a, FloatVector* v);                                                      // x = x + a*v
void add(float a, FloatVector* v, float b, FloatVector* w);                     // x = x + a*v + b*w
void add(float a, FloatVector* v, float b, FloatVector* w,                      // x = x + a*v + b*w + c*z
                                                float c, FloatVector* z);
void add(float a, float b, FloatVector* v);                                     // x = a*x + b*v
void add(float a, float b, FloatVector* v, float c, FloatVector* w);    // x = a*x + b*v + c*w

void saxpy(float a, FloatVector* v);                                            // x = a*x + v

void gaxpy(AFSymMatrix* A, FloatVector* v);                                     // x = x + A*v
void gaxpy(float a, AFSymMatrix* A, FloatVector* v);                            // x = a*x + A*v
void gaxpy(float a, float b, AFSymMatrix* A, FloatVector* v);           // x = a*x + b*A*v
void gaxpy(float a, float b, AFSymMatrix* A, FloatVector* v, 
                                                float c, FloatVector* w);               // x = a*x + b*A*v + c*w
void gaxpy(float a, float b, AFSymMatrix* A, FloatVector* v, 
                                float c, AFSymMatrix* B, FloatVector* w);               // x = a*x + b*A*v + c*B*w

float prodScalar(FloatVector* v);

// friends
friend float operator*(FloatVectorT& vt, FloatVector& u);                       // scalar product

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

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

#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.