F_L1BiDiag.hpp Source File

00001 #ifndef __F_L1BiDiag_H__
00002 #define __F_L1BiDiag_H__
00003 
00004 
00005 
00026 #include <stdio.h>
00027 #include "FloatVector.hpp"
00028 #include "FloatVectorT.hpp"
00029 
00030 #include "AFSymMatrix.hpp"
00031 
00032 class F_L1BiDiag : public AFSymMatrix
00033 {
00034 private:
00035         
00036 FloatVector*            l;                                      
00037 
00038 public:
00039         
00040 F_L1BiDiag(int asize, float val=0.0);
00041 F_L1BiDiag(const F_L1BiDiag& v);
00042 F_L1BiDiag operator=(const F_L1BiDiag& v);
00043 
00044 virtual ~F_L1BiDiag(){delete l;}
00045 
00046 virtual AFloatMatrix* copy(){return 0;}
00047 virtual AFloatMatrix* t(AFloatMatrix* result=0){return 0;}
00048 
00049 void load(F_L1BiDiag* m);
00050 void load(FloatVector* anL);
00051 
00052 virtual int size()const { return (2*width-1); }
00053 
00054 FloatVector* getLvalues(){ return l; }
00055 
00056 // base 0
00057 virtual void set0(int i, int j, float value);
00058 virtual float get0(int i, int j);
00059 
00060 inline void setD0(int i, float value){}
00061 inline float getD0(int i) const{ return 1.0; }
00062 
00063 virtual void setL0(int i, float value){ l->set0(i, value); }
00064 virtual float getL0(int i)const{ return l->get0(i); }
00065 
00066 // base 1
00067 virtual void set(int i, int j, float value){ set0(i-1, j-1, value); }
00068 virtual float get(int i, int j){ return get0(i-1, j-1); }
00069 
00070 inline void setD(int i, float value){}
00071 inline float getD(int i) const{ return 1.0; }
00072 
00073 virtual void setL(int i, float value){ l->set(i, value); }
00074 virtual float getL(int i)const{ return l->get(i); }
00075 
00076 // computations
00077 
00078 virtual void setAll(float value=0.0){ l->setAll(value); }
00079 
00080 // direct solvers
00081 virtual FloatVector* solve(FloatVector* b, FloatVector* x=0);           // L1x=b
00082 
00083 virtual FloatVector* linearSolverL1(FloatVector* b, FloatVector* x=0);          // L1x=b
00084 
00085 // direct inversion L
00086 AFSymMatrix* invert();          // Linv = L^-1
00087 
00088 virtual float det(){return 0;}
00089 virtual float trace(){return 0;}
00090 
00091 virtual float norme2();
00092 virtual float sum();
00093 
00094 virtual float minimum();
00095 virtual float maximum();
00096 virtual float sigma();
00097 
00098 // scalar single operations
00099 void operator*=(float value);
00100 void operator/=(float value);
00101 
00102 virtual void add(float value){}
00103 virtual void subst(float value){}
00104 virtual void mult(float value);
00105 virtual void div(float value);
00106 
00107 // vector single operations
00108 void operator+=(F_L1BiDiag& m);
00109 void operator-=(F_L1BiDiag& m);
00110 
00111 virtual void add(AFloatMatrix& m){}
00112 virtual void subst(AFloatMatrix& m){}
00113 
00114 // u= A*v including implicit transposition
00115 FloatVector* mult_Av(FloatVector* v, FloatVector* result=0);
00116 FloatVector* mult_ATv(FloatVector* v, FloatVector* result=0);
00117 // u= v*A
00118 FloatVector* mult_vA(FloatVector* v, FloatVector* result=0)     { return mult_ATv(v, result); }
00119 FloatVector* mult_vAT(FloatVector* vt, FloatVector* result=0){ return mult_Av(vt, result); }
00120 
00121 // sub vector usage
00122 // u= A*v
00123 FloatVector* mult_Av(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0);
00124 FloatVector* mult_ATv(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0);
00125 // u= v*A
00126 FloatVector* mult_vA(FloatVector* v, int row0, int col0, bool incremental=false, FloatVector* result=0)
00127                         { return mult_ATv(v, col0, row0, incremental, result); }
00128 FloatVector* mult_vAT(FloatVector* vt, int row0, int col0, bool incremental=false, FloatVector* result=0)
00129                         { return mult_Av(vt, col0, row0, incremental, result); }
00130 
00131 
00132 virtual void output();
00133 virtual void output(FILE* file);
00134 };
00135 
00136 #endif
00137 
00138