informatique 3

template<class T> matrix matrix::CholeskyFactor() 
{ 
                //on sous-entend que la matrice est SDP. 
                int dim     = getRowSize(); 
                matrix<T> A(dim, T()); 
                vector<T> v(dim); 
                int pos = 0; 
                T value; 
                for (int j=1; j<=dim; j++) 
                { 
                                for (int i=j; i<=dim; i++) 
                               { 
                                               v.at(i-1) = getElement(i,j); 
                                               for (int k=1; k<=j-1; k++) 
                                               { 
                                                               v.at(i-1) -= A(j,k)*A(i,k); 
                                               } 
                                               value = v.at(i-1)/sqrt(v.at(j-1)); 
                                               A.setElement(i, j, value); 
                               } 
                } 
                return A; 
}; 
template<class T> matrix matrix::EigenVectors(matrix& sigma) 
{ 
}; 
template<class T> matrix matrix::EigenValues(matrix& sigma) 
{ 
}; 
template<class T> bool matrix::isSymmetric() const 
{ 
                if (isSquared()) 
                { 
                               int dim = getJump(); 
                               for (int i=0; i<dim; i++) 
                               { 
                                               for (int j=i+1; j<dim; j++) 
                                               { 
                                                               if (operator()(i+1, j+1) != operator()(j+1, i+1)) 
                                                                              return false; 
                                               } 
                               } 
                               return true; 
                } 
                return false; 
}; 
template<class T> bool matrix::isSquaredDiag() const 
{ 
                int dim = getJump(); 
                T value; 
                if (isSquared()) 
                { 
                               for (int i=0; i<dim; i++) 
                               { 
                                               for (int j=i+1; j<dim; j++) 
                                               { 
                                                               value = operator()(i+1, j+1); 
                                                               if (value != T()) 
                                                                              return false; 
                                                               else 
                                                               { 
                                                                              if (value != operator()(i+1, j+1)) 
                                                                                              return false; 
                                                               } 
                                               } 
                               } 
                               return true; 
                } 
                return false; 
}; 
//Is the matrix definite positive. 
template<class T> bool matrix::isSdp() const 
{ 
                return true; 
}; 
template<class T> matrix matrix::getSubMatrix(vector& indices) const 
{ 
                //on sous-entend que la liste d'indices est bien proportionnée. 
                int size = indices.size(); 
                int total = size*size; 
                vector<T> elem(total);            
                int pos1; 
                int pos2; 
                T value; 
                for (int i= 0; i<size; i++) 
                { 
                               pos1 = indices[i]; 
                               for (int j=0; j<size; j++) 
                               { 
                                               pos2 = indices[j]; 
                                               value = operator()(pos1, pos2); 
                                               elem[i*size+j] = value; 
                               } 
                } 
                return matrix(elem, size); 
}; 
//External. 
//operator+ 
template<class T> matrix operator+(T value) 
{ 
                vector<T> elem1 = this.getElem();          
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] + value; 
                } 
                return matrix<T>(elem, this.getJump());                 
}; 
template<class T> matrix operator+(const matrix& x, T value) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] + value; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
template<class T> matrix operator+(T value, const matrix& x) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] + value; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
//operator- 
template<class T> matrix operator-(T value) 
{ 
                vector<T> elem1 = this.getElem();          
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] - value; 
                } 
                return matrix<T>(elem, this.getJump());                 
}; 
template<class T> matrix operator-(const matrix& x, T value) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] - value; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
template<class T> matrix operator-(T value, const matrix& x) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = value-elem1[i]; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
//operator* 
template<class T> matrix operator*(matrix& x, T value) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] * value; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
template<class T> matrix operator*(T value, matrix& x) 
{ 
                vector<T> elem1 = x.getElem();             
                int size = elem1.size(); 
                vector<T> elem = vector(size); 
                for (int i=0; i<size; i++) 
                { 
                               elem[i] = elem1[i] * value; 
                } 
                return matrix<T>(elem, x.getJump());     
}; 
//operator+= 
template<class T> matrix& operator+=(matrix& x, T value) 
{ 
                vector<T> elem2 = x.itsElem;                 
                int size = elem2.size(); 
                for (int i=0; i<size; i++) 
                               x.itsElem[i] += value; 
                return x; 
}; 
//operator-= 
template<class T> matrix& operator-=(matrix& x, T value) 
{ 
                vector<T> elem2 = x.getElem();             
                int size = elem2.size(); 
                for (int i=0; i<size; i++) 
                               (x.getElem())[i] -= value; 
                return x; 
}; 

 
Noter cette page

0/10 sur 0 vote

Sélectionnez une note dans le menu déroulant.
Commentaire (0)

Aucun commentaire

Ajouter un commentaire
Vous

Votre message

Plus de smileys

Champ de sécurité

Veuillez recopier les caractères de l'image :



Dernière mise à jour de cette page le 21/03/2008

Créer un site internet gratuit avec E-monsite.com - Signaler un contenu illicite - Voir d'autres sites dans la catégorie Pages personnelles
Videos Droles - Clips musique - Cours création de site web