021
08.01.2004, 18:32 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)
|
um nochmal auf das zu kommen was ich meinte
damit hatte ich angefangen...
mit dem invertieren oder determinate oder gleichungssystem lösen würde es glaube ich keine probleme geben...
Ich will nur keine Matrixklasse haben bei der man nicht mal multiplizieren kann...
vector hab ich genommen weil ich noch nicht wusste ob ich erlauben will eine matrix mal später aufzublähen... Hat sich irgendwie nicht bewährt ist wahrscheinlich doch sinnvoller gleich ein array zu nehmen...
würde mich freuen beefy, wenn du mir helfen würdest die multiplikation zu schreiben...
| C++: |
#ifndef CMATRIX_TEMPLATE_H
#define CMATRIX_TEMPLATE_H
#include <iostream>
#include <vector>
#define MATRIX_TEMPLATE template <class Typ, int zeilen, int spalten>
MATRIX_TEMPLATE
class CMatrix{
private:
std::vector<std::vector<Typ> > matrix;
public:
//CMatrix();
CMatrix(Typ value=0);
CMatrix(Typ* values);
CMatrix(Typ** values);
CMatrix(std::vector<std::vector<Typ> > m);
CMatrix(CMatrix&);//:matrix(m.matrix){};
void operator=(CMatrix& m);
bool operator==(CMatrix& m);
std::vector<Typ>& operator[](int& index);
CMatrix<Typ,spalten,zeilen> operator!();
// CMatrix operator~();
CMatrix operator+(CMatrix& m);
CMatrix operator-(CMatrix& m);
CMatrix operator*(Typ& s);
// CMatrix operator*(CMatrix& m);
// CMatrix<Typ,zeilen,int> operator*(CMatrix<Typ,spalten,int>& m);
template<int D>
CMatrix<Typ,zeilen,D>operator*(CMatrix<Typ,spalten,D>& m){
CMatrix<Typ,zeilen,D> rv(int(0));
for(int j=0;j<rv.matrix[0].size();++j)
for(int i=0;i<rv.matrix.size();++i)
for(int h=0;h<matrix.size();++h)
rv[i][j]+=matrix[h][j]*m[i][h];
return rv;
}
CMatrix operator/(Typ& s);
void Matrix_ausgeben();
};
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten>::CMatrix(Typ value):matrix(spalten,std::vector<Typ>(zeilen)){
for(int j=0;j<zeilen;++j)
for(int i=0;i<spalten;++i)
matrix[i][j]=value;
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten>::CMatrix(Typ* values):matrix(spalten,std::vector<Typ>(zeilen)){
for(int j=0;j<zeilen;++j)
for(int i=0;i<spalten;++i)
matrix[i][j]=values[i+j*x];
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten>::CMatrix(Typ** values):matrix(spalten,std::vector<Typ>(zeilen)){
for(int j=0;j<zeilen;++j)
for(int i=0;i<spalten;++i)
matrix[i][j]=values[i][j];
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten>::CMatrix(std::vector<std::vector<Typ> > m):matrix(m){}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten>::CMatrix(CMatrix& m):matrix(m.matrix){}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
void CMatrix<Typ,zeilen,spalten>::operator=(CMatrix<Typ,zeilen,spalten>& m){
// if(matrix.size()!=m.matrix.size() || matrix[0].size()!=m.matrix[0].size()) return;
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
matrix[i][j]=m[i][j];
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
bool CMatrix<Typ,zeilen,spalten>::operator==(CMatrix& m){
if(matrix.size()!=m.matrix.size() || matrix[0].size()!=m.matrix[0].size()) return false;
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
if(matrix[i][j]!=m[i][j])return false;
return true;
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
std::vector<Typ>& CMatrix<Typ,zeilen,spalten>::operator[](int& index){
return matrix[index];
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,spalten,zeilen> CMatrix<Typ,zeilen,spalten>::operator!(){
// CMatrix rv(matrix.size(),matrix[0].size());
CMatrix<Typ,spalten,zeilen> rv(int(0));
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
rv[j][i]=matrix[i][j];
return rv;
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten> CMatrix<Typ,zeilen,spalten>::operator+(CMatrix& m){
CMatrix rv(*this);
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
rv[i][j]+=m[i][j];
return rv;
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten> CMatrix<Typ,zeilen,spalten>::operator-(CMatrix& m){
CMatrix rv(*this);
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
rv[i][j]-=m[i][j];
return rv;
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten> CMatrix<Typ,zeilen,spalten>::operator*(Typ& s){
CMatrix rv(*this);
for(int j=0;j<matrix[0].size();++j)
for(int i=0;i<matrix.size();++i)
rv[i][j]*=s;
return rv;
}
/*
//---------------------------------------------------------------------------------------
//template<class Typ, int zeilen, int spalten,int D>
MATRIX_TEMPLATE
template<int D>
CMatrix<Typ,zeilen,D> CMatrix<Typ,zeilen,spalten>::operator*(CMatrix<Typ,spalten,D>& m){
CMatrix<Typ,zeilen,D> rv(int(0));
for(int j=0;j<rv.matrix[0].size();++j)
for(int i=0;i<rv.matrix.size();++i)
for(int h=0;h<matrix.size();++h)
rv[i][j]+=matrix[h][j]*m[i][h];
return rv;
}
*/
/*
template <class Typ,int zeilen,int spalten>
CMatrix<Typ,zeilen,zeilen> CMatrix<Typ,zeilen,spalten>::operator*(CMatrix<Typ,spalten,zeilen>& m){
// CMatrix rv(matrix[0].size(),m.matrix.size());
CMatrix rv(int(0));
for(int j=0;j<rv.matrix[0].size();++j)
for(int i=0;i<rv.matrix.size();++i)
for(int h=0;h<matrix.size();++h)
rv[i][j]+=matrix[h][j]*m[i][h];
return rv;
}
*/
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
CMatrix<Typ,zeilen,spalten> CMatrix<Typ,zeilen,spalten>::operator/(Typ& s){
return CMatrix(*this)*(1.0/s);
}
//---------------------------------------------------------------------------------------
MATRIX_TEMPLATE
void CMatrix<Typ,zeilen,spalten>::Matrix_ausgeben(){
// std::cout<<matrix.size()<<"\t"<<matrix[0].size()<<std::endl;
std::cout<<std::endl;
for(int j=0;j<matrix[0].size();++j,std::cout<<std::endl)
for(int i=0;i<matrix.size();++i)
std::cout<<matrix[i][j]<<"\t";
std::cout<<std::endl;
}
#undef MATRIX_TEMPLATE
#endif
|
--
...fleißig wie zwei Weißbrote |
