informatique 2

//Constant constructor
template<class T> matrix::matrix():
itsJump(0), itsElem(vector<T>(0))
{
};
template<class T> matrix::matrix(int lines, int columns, T value):
itsJump(columns), itsElem(vector<T>(lines*columns, value))
{
};
//Squared matrix constructor
template<class T> matrix::matrix(int dim, T value)
{
                int total = dim*dim;
                setJump(dim);
                setElem(vector<T>(total, T()));
                for (int i=0; i<dim; i++)
                {
                               (getElem())[i*dim +i] = value;
                }
};
//Heavy constructor
template<class T> matrix::matrix(vector& inputs, int jump) :
itsElem(inputs), itsJump(jump)
{
};
//Squared diag constructor
template<class T> matrix::matrix(vector& diag) :
itsJump(diag.size())
{
                int dim = diag.size();
                int total = dim*dim;
                itsElem = vector<T>(total, T());
                for (int i=0; i<dim; i++)
                {
                               (getElem())[i*dim + i] = diag[i];
                }
};
//Copy constructor
template<class T> matrix::matrix(const matrix& x)
{
                if (this!= &x)
                {
                               itsElem = x.getElem();
                               itsJump = x.getJump();
                }
};
//operator=
template<class T> matrix matrix::operator= (const matrix& x)
{
                itsElem = x.getElem();
                itsJump = x.getJump();
                return *this;
};
//operator||
template<class T> bool matrix::operator|| (const matrix& x)
{
                //Number of columns.
                if (getJump() != x.getJump())
                               return false;
                //Total elements: we check implicitely the number of lines.
                int total = getElem().size();
                int xtotal = x.getElem().size();
                if (total != xtotal)
                               return false;
                return true;
};
//operator|
template<class T> bool matrix::operator| (const matrix& x)
{
                //right matrix.
                int rLines = x.getElem().size()/x.getJump();
                //left matrix.
                int lCols = getJump();
                if (rLines != lCols)
                               return false;
                return true;
};
//operator==
template<class T> bool matrix::operator== (const matrix& x)
{
                //Number of columns.
                if (getJump() != x.getJump())
                               return false;
                //Total elements: we check implicitely the number of lines.
                int total = getElem().size();
                int xtotal = x.getElem().size();
                if (total != xtotal)
                               return false;
                //Use vector<T> operator==
                if (getElem() != x.getElem())
                               return false;
                return true;
};
//operator*
template<class T> matrix matrix::operator* (matrix& x)
{
                //on sous-entend que le contrôle est fait au préalable.
                int lines = getElem().size()/itsJump;
                int cols = x.getJump();
                int total = lines*cols;
                vector<T> multelem(total, T());
                int pos = 0;
                vector<T> u;
                vector<T> v;
                T value = T();
                for (int i=1; i<=lines; i++)
                {
                               for (int j=1; j<=cols; j++)
                               {
                                               pos = Position(i, j, cols);
                                               u = getLine(i);
                                               v = x.getCol(j);
                                               value = ScalarPositive<T>(u, v);
                                               multelem[pos] = value;
                               }
                }
                return matrix(multelem, cols);
};
//operator+
template<class T> matrix matrix::operator+ (const matrix& x)
{
                vector<T> elem1 = getElem();
                vector<T> elem2 = x.itsElem;
                int size = elem1.size();
                vector<T> elem = vector(size);
                for (int i=0; i<size; i++)
                               elem[i] = elem1[i] + elem2[i];
                return matrix(elem, itsJump);
};
//operator+=
template<class T> matrix& matrix::operator+= (const matrix& x)
{
                vector<T> elem2 = x.getElem();
                int size = elem2.size();
                for (int i=0; i<size; i++)
                               (getElem())[i] += elem2[i];
                return *this;
};
//operator-
template<class T> matrix matrix::operator- (const matrix& x)
{
                vector<T> elem1 = itsElem;
                vector<T> elem2 = x.getElem();
                int size = elem1.size();
                vector<T> elem = vector(size);
                for (int i=0; i<size; i++)
                {
                               elem[i] = elem1[i] - elem2[i];
                }
                return matrix(elem, itsJump);
};
//operator-=
template<class T> matrix& matrix::operator-= (const matrix& x)
{
                vector<T> elem2 = x.getElem();
                int size = elem2.size();

                for (int i=0; i<size; i++)
                               (getElem())[i] -= elem2[i];
                return *this;
};
//Déterminant.
template<class T> T matrix::operator!()
{
                return T();
};
//Accesseur par indiçage
template<class T> T matrix::operator() (int line, int col) const
{
                int value = col - 1 + (line - 1) * getJump();
                return (getElem())[value];
};
//Matrice transposée
template<class T> matrix matrix::operator~()
{
                int total = getElem().size();
                int jumpT = total/getJump();
                vector<T> elemT(total);
                matrix<T> Mt = matrix(elemT, jumpT);
                int lines = jumpT;
                int cols = getJump();
                int pos=0;
                int tpos=0;
                for (int i=1; i<=lines; i++)
                {
                               for (int j=1; j<=cols;j++)
                               {
                                               pos = Position(i, j, cols);
                                               tpos = Position(j, i, jumpT);
                                               elemT[tpos] = (getElem())[pos];
                               }
                }
                return matrix(elemT, jumpT);
};
template<class T> matrix& matrix::permuteLines(int line1, int line2)
{
                T value;
                int jump = getJump();
                for (int i=0; i<jump; i++)
                {
                               value = itsElem[(line1-1)*jump + i];
                               itsElem[(line1-1)*jump + i] = itsElem[(line2-1)*jump + i];
                               itsElem[(line2-1)*itsJump + i] = value;
                }
                return *this;
};
template<class T> matrix& matrix::permuteCols(int col1, int col2)
{
                T value;
                int colSize = getColumnSize();
                for (int i=0; i<colSize; i++)
                {
                               value = itsElem[i*itsJump + col1-1];
                               itsElem[i*itsJump + col1-1] = itsElem[i*itsJump + col2-1];
                               itsElem[i*itsJump + col2-1] = value;
                }
                return *this;
};
//matrice quelconque.
template<class T> matrix matrix::InvMatrix()
{
};

Noter cette page

0/10 sur 0 vote