Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   Related Pages  

FTriDiagonalMatrix.hpp

00001 #ifndef __FTriDiagonalMatrix_H__
00002 #define __FTriDiagonalMatrix_H__
00003 
00004 
00005 
00025 #include <stdio.h>
00026 #include "FloatVector.hpp"
00027 
00028 #include "AFSymMatrix.hpp"
00029 
00030 class FTriDiagonalMatrix : public AFSymMatrix
00031 {
00032 private:
00033         
00034 int                             N;
00035 
00036 FloatVector*            up;                                     // N-1 size upper diagonal 
00037 FloatVector*            d;                                      // N size diagonal
00038 FloatVector*            low;                            // N-1 size lower diagonal 
00039 
00040 public:
00041         
00042 FTriDiagonalMatrix(int asize, float val=0.0);
00043 FTriDiagonalMatrix(int asize, float lval, float dval, float uval);
00044 FTriDiagonalMatrix(const FTriDiagonalMatrix& v);
00045 FTriDiagonalMatrix operator=(const FTriDiagonalMatrix& v);
00046 
00047 virtual ~FTriDiagonalMatrix(){ delete d; delete up; delete low;}
00048 
00049 virtual AFloatMatrix* copy(){ return new FTriDiagonalMatrix(*this); }
00050 virtual AFloatMatrix* t(AFloatMatrix* result=0){return (AFloatMatrix*)0;}
00051 
00052 // no diagonal
00053 virtual AFSymMatrix* copyL0();                          
00054 virtual AFSymMatrix* copyU0();
00055 // with diagonal
00056 virtual AFSymMatrix* copyL();                           
00057 virtual AFSymMatrix* copyU();
00058 // with unit diagonal
00059 virtual AFSymMatrix* copyL1();                          
00060 virtual AFSymMatrix* copyU1();
00061 
00062 void load(FTriDiagonalMatrix* m);
00063 void load(FloatVector* u1, FloatVector* d1, FloatVector* l1);
00064 
00065 virtual int size()const { return (3*N-2); }
00066 
00067 FloatVector* getUvalues(){ return up; }
00068 FloatVector* getDvalues(){ return d; }
00069 FloatVector* getLvalues(){ return low; }
00070 
00071 // base 0
00072 virtual void set0(int i, int j, float value);
00073 virtual float get0(int i, int j);
00074 
00075 inline void setD0(int i, float value){ d->set0(i, value); }
00076 inline float getD0(int i)const { return d->get0(i); }
00077 
00078 inline void setU0(int i, float value){ up->set0(i, value); }
00079 inline float getU0(int i)const { return up->get0(i); }
00080 
00081 inline void setL0(int i, float value){ low->set0(i, value); }
00082 inline float getL0(int i)const { return low->get0(i); }
00083 
00084 virtual Simple1DIndexList* indexesInRow0(int k, Simple1DIndexList* oldRow=0);
00085 virtual Simple1DIndexList* indexesInCol0(int k, Simple1DIndexList* oldCol=0);
00086 
00087 // base 1
00088 virtual void set(int i, int j, float value);
00089 virtual float get(int i, int j);
00090 
00091 inline void setD(int i, float value){ d->set(i, value); }
00092 inline float getD(int i)const { return d->get(i); }
00093 
00094 inline void setU(int i, float value){ up->set(i, value); }
00095 inline float getU(int i)const { return up->get(i); }
00096 
00097 inline void setL(int i, float value){ low->set(i, value); }
00098 inline float getL(int i)const { return low->get(i); }
00099 
00100 virtual Simple1DIndexList* indexesInRow(int k, Simple1DIndexList* oldRow=0);
00101 virtual Simple1DIndexList* indexesInCol(int k, Simple1DIndexList* oldCol=0);
00102 
00103 // direct solvers
00104 virtual FloatVector* linearSolverU0(FloatVector* b, FloatVector* x=0);          // Ux=b
00105 virtual FloatVector* linearSolverU1(FloatVector* b, FloatVector* x=0);          // U1x=b
00106 virtual FloatVector* linearSolverL0(FloatVector* b, FloatVector* x=0);          // Lx=b
00107 virtual FloatVector* linearSolverL1(FloatVector* b, FloatVector* x=0);          // L1x=b
00108 
00109 // factorisation complete
00110 virtual AFSymMatrix* factorisationL1U0();               // L1/U0 Doolittle
00111 virtual AFSymMatrix* factorisationL0U1();               // L0/U1 Crout
00112 
00113 // single step iterative linear solvers: Au=b, single iteration
00114 virtual FloatVector* gaussSeidel(FloatVector* b, FloatVector* x=0);
00115 virtual FloatVector* jacobi(FloatVector* b, FloatVector* x=0, FloatVector* dest=0);
00116 virtual FloatVector* sor(FloatVector* b, float omega=1.0, FloatVector* x=0);
00117 
00118 virtual AFSymMatrix* jacobiMatrix();                                    // used to compute SOR omega
00119 
00120 // computations
00121 
00122 virtual void setAll(float value=0.0);
00123 
00124 virtual float det();
00125 virtual float trace();
00126 
00127 virtual float norme2();
00128 virtual float sum();
00129 
00130 virtual float minimum();
00131 virtual float maximum();
00132 virtual float sigma();
00133 
00134 // math vectorial op
00135 FTriDiagonalMatrix sqrt();
00136 FTriDiagonalMatrix pow(float pow);
00137 FTriDiagonalMatrix sqr();
00138 FTriDiagonalMatrix exp();
00139 FTriDiagonalMatrix log();
00140 FTriDiagonalMatrix log(float base);
00141 
00142 FTriDiagonalMatrix sin();
00143 FTriDiagonalMatrix cos();
00144 FTriDiagonalMatrix tan();
00145 
00146 // scalar single operations
00147 void operator+=(float value);
00148 void operator-=(float value);
00149 void operator*=(float value);
00150 void operator/=(float value);
00151 
00152 virtual void add(float value);
00153 virtual void subst(float value);
00154 virtual void mult(float value);
00155 virtual void div(float value);
00156 
00157 // vector single operations
00158 void operator+=(const FTriDiagonalMatrix& m);
00159 void operator-=(const FTriDiagonalMatrix& m);
00160 
00161 virtual void add(AFloatMatrix& m){}
00162 virtual void subst(AFloatMatrix& m){}
00163 
00164 // u= A*v including implicit transposition
00165 FloatVector* mult_Av(FloatVector* v, FloatVector* result=0);
00166 FloatVector* mult_ATv(FloatVector* v, FloatVector* result=0);
00167 // u= v*A
00168 FloatVector* mult_vA(FloatVector* v, FloatVector* result=0)     { return mult_ATv(v, result); }
00169 FloatVector* mult_vAT(FloatVector* vt, FloatVector* result=0){ return mult_Av(vt, result); }
00170 
00171 // sub vector usage
00172 // u= A*v
00173 FloatVector* mult_Av(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0);
00174 FloatVector* mult_ATv(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0);
00175 // u= v*A
00176 FloatVector* mult_vA(FloatVector* v, int row0, int col0, bool incremental=false, FloatVector* result=0)
00177                         { return mult_ATv(v, col0, row0, incremental, result); }
00178 FloatVector* mult_vAT(FloatVector* vt, int row0, int col0, bool incremental=false, FloatVector* result=0)
00179                         { return mult_Av(vt, col0, row0, incremental, result); }
00180 
00181 // friends
00182 friend FloatVectorT operator*(const FloatVectorT& vt, const FTriDiagonalMatrix& m);     
00183 friend FloatVector operator*(const FTriDiagonalMatrix& m, const FloatVector& v);        
00184         
00185 void output();
00186 void output(FILE* file);
00187 };
00188 
00189 #endif
00190 
00191 
00192          
SourceForge.net Logo
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.
bern_bdc@hotmail.com