00001 #ifndef __F_L1_H__ 00002 #define __F_L1_H__ 00003 00023 #include <stdio.h> 00024 #include "FloatVector.hpp" 00025 00026 #include "AFSymMatrix.hpp" 00027 00028 00029 class F_L1 : public AFSymMatrix 00030 { 00031 private: 00032 00033 float** data; 00034 00035 public: 00036 00037 F_L1(int n, float value=0.0); 00038 F_L1(const F_L1& m); 00039 F_L1 operator=(const F_L1& m); 00040 00041 virtual ~F_L1(); 00042 00043 virtual AFSymMatrix* copyAnn(); 00044 virtual AFloatMatrix* copy(); 00045 virtual AFloatMatrix* t(AFloatMatrix* t=0){ return 0;} 00046 00047 // base 0 00048 virtual void set0(int i, int j, float value); 00049 virtual float get0(int i, int j); 00050 00051 // base 1 00052 virtual void set(int i, int j, float value){ set0(i-1, j-1, value); } 00053 virtual float get(int i, int j){ return get0(i-1, j-1); } 00054 00055 // computations 00056 virtual void setAll(float value=0.0); 00057 00058 virtual float det(); 00059 virtual float trace(); 00060 00061 virtual float norme2(); 00062 virtual float normeF(); // Frobenuis norme= trace(At*A) 00063 virtual float norme1(); 00064 virtual float normeInf(); 00065 00066 virtual float sum(); 00067 virtual float sum2(); 00068 00069 virtual float minimum(); 00070 virtual float maximum(); 00071 virtual float sigma(); 00072 00073 // math vectorial op 00074 F_L1 sqrt(); 00075 F_L1 pow(float pow); 00076 F_L1 sqr(); 00077 F_L1 exp(); 00078 F_L1 log(); 00079 F_L1 log(float base); 00080 00081 F_L1 sin(); 00082 F_L1 cos(); 00083 F_L1 tan(); 00084 00085 // scalar single operations 00086 void operator+=(float value); 00087 void operator-=(float value); 00088 void operator*=(float value); 00089 void operator/=(float value); 00090 00091 virtual void add(float value); 00092 virtual void subst(float value); 00093 virtual void mult(float value); 00094 virtual void div(float value); 00095 00096 // vector single operations 00097 void operator+=(F_L1& m); 00098 void operator-=(F_L1& m); 00099 00100 // L1*x=b <==> 00101 virtual FloatVector* solve(FloatVector* b, FloatVector* x=0); 00102 00103 // u= A*v including implicit transposition 00104 virtual FloatVector* mult_Av(FloatVector* v, FloatVector* result=0); 00105 virtual FloatVector* mult_ATv(FloatVector* v, FloatVector* result=0); 00106 // u= v*A 00107 virtual FloatVector* mult_vA(FloatVector* v, FloatVector* result=0) { return mult_ATv(v, result); } 00108 virtual FloatVector* mult_vAT(FloatVector* vt, FloatVector* result=0){ return mult_Av(vt, result); } 00109 00110 // sub vector usage 00111 // u= A*v 00112 FloatVector* mult_Av(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0); 00113 FloatVector* mult_ATv(FloatVector* v, int col0, int row0, bool incremental=false, FloatVector* result=0); 00114 // u= v*A 00115 FloatVector* mult_vA(FloatVector* v, int row0, int col0, bool incremental=false, FloatVector* result=0) 00116 { return mult_ATv(v, col0, row0, incremental, result); } 00117 FloatVector* mult_vAT(FloatVector* vt, int row0, int col0, bool incremental=false, FloatVector* result=0) 00118 { return mult_Av(vt, col0, row0, incremental, result); } 00119 00120 00121 // direct inversion U, L 00122 AFSymMatrix* invert(); // Uinv = U^-1 00123 00124 virtual void add(AFloatMatrix& M); 00125 virtual void subst(AFloatMatrix& M); 00126 }; 00127 00128 #endif 00129 00130