{

Matrix<VARTYPE> C=A;

for(int i=0,j; i<A.m; i++)

for(j=0; j<A.n; j++)

C(i,j)+=B(i,j);

return C;

}

template <class VARTYPE>

Matrix<VARTYPE> operator-(const Matrix<VARTYPE> &A, const Matrix<VARTYPE> &B)

{

Matrix<VARTYPE> C=A;

for(int i=0, j; i<A.m; i++)

for(j=0;j<A.n;j++)

C(i,j)-=B(i,j);

return C;

}

template <class VARTYPE>

Matrix<VARTYPE> operator*(const Matrix<VARTYPE> &A,const Matrix<VARTYPE> &B)

{

Matrix<VARTYPE> C(A.m,B.n);

if (A.n!=B.m)

{

if(A.m==3 && A.n==1 && B.m==3 && B.n==1)

{

C(0)=A(1)*B(2)-A(2)*B(1);

C(1)=A(2)*B(0)-A(0)*B(2);

C(2)=A(0)*B(1)-A(1)*B(0);

}

else

A.ERROR_MATRIX(2);

}

else

{

for(int i=0,j,k;i<C.m;i++)

for(j=0;j<C.n;j++)

for(k=0;k<A.n;k++)

C(i,j)+=A(i,k)*B(k,j);

}

return C;

}

template <class VARTYPE>//умножение числа на матрицу

Matrix<VARTYPE> operator*(const double &f,const Matrix<VARTYPE> &A)

{

Matrix<VARTYPE> B=A;

for(int i=0,j;i<A.m;i++)

for(j=0;j<A.n;j++)

B(i,j)*=f;

return B;

}

template <class VARTYPE>// умножение матрицы на число

Matrix<VARTYPE> operator*(const Matrix<VARTYPE> &A, const double &f)

{

Matrix<VARTYPE> B=A;

for(int i=0,j;i<A.m;i++)

for(j=0;j<A.n;j++)

B(i,j)*=f;

return B;

}

template <class VARTYPE>

Matrix<VARTYPE>& Matrix<VARTYPE>::newsize(dim M, dim N)

{ delete [] matr;

m=M;

n=N;

if (N && M) { matr=new VARTYPE[m*n];

if (!matr) ERROR_MATRIX(1);

setmem(matr,sizeof(VARTYPE)*m*n,0); }

else { m=n=0; matr=(VARTYPE*)0; }

return *this;

}

template <class VARTYPE>

ostream& operator<<(ostream &out,Matrix<VARTYPE> &A)

{ for(int i=0,j;i<A.size_row();i++)

{ for(j=0;j<A.size_col();j++)

out << A(i,j)<< " ";

out<<endl;

}

return out;

}

template <class VARTYPE>

int operator>>(istream &inp,Matrix<VARTYPE> &A)

{ for(int i=0,j;i<A.size_row();i++)

for(j=0;j<A.size_col();j++) if( !(inp>>A(i,j)) ) return 1;

return 0;

}

template <class VARTYPE>

void Matrix<VARTYPE>::swap_line(dim L1, dim L2)

{

if (L1==L2)

return;

double b;

for(int j=0;j<n;j++)

{

b=(*this)(L1,j);

(*this)(L1,j)=(*this)(L2,j);

(*this)(L2,j)=b;

}

}

template <class VARTYPE>

void Matrix<VARTYPE>::swap_column(dim C1, dim C2)

{

if (C1==C2)

return;

double b;

for(int i=0;i<m;i++)

{

b=(*this)(i,C1);

(*this)(i,C1)=(*this)(i,C2);

(*this)(i,C2)=b;

}

}

template <class VARTYPE>

dim Matrix<VARTYPE>::read(ifstream &finp)

{ (finp.get(m)).get(n); delete []matr; matr=new VARTYPE[m*n];

if(!matr) ERROR_MATRIX(1);

setmem(matr,sizeof(VARTYPE)*m*n,0);

finp.read((char *)matr,sizeof(VARTYPE)*m*n); return finp.fail();

}

template <class VARTYPE>

dim Matrix<VARTYPE>::write(ofstream &fout)

{ (fout.put(m)).put(n);

(fout.write((char *)matr,sizeof(VARTYPE)*m*n))<<flush; return fout.fail();

}

template <class VARTYPE>

VARTYPE operator%(const Matrix<VARTYPE> &A, const Matrix<VARTYPE>&B)

{

if(A.n!=1 || B.n!=1) A.ERROR_MATRIX(9);

if(A.m!=B.m) A.ERROR_MATRIX(0);

VARTYPE scalarmul = 0;

for(int i=0; i<A.m; i++)

scalarmul = scalarmul+A(i)*B(i);

return scalarmul;

}

template <class VARTYPE>

void Matrix<VARTYPE>::ERROR_MATRIX(dim E) const

{ static char *message[] = {

"Матрицы должны иметь одинаковую размерность", //0

"Не выделена память!", //1

"Матрицы не согласованы для умножения", //2

"Степень должна быть больше нуля или -1", //3

"Матрица должна быть квадратной", //4

"Нулевой ведущий элемент в преобразовании Гаусса", //5

"Вставка невозможна из-за перекрытия базовой матрицы", //6

"Извлекаемая матрица выходит за границы базовой", //7

"Выход за границы. Попытка доступа к несущ. элементу", //8

"Это не вектор!"}; //9

cerr<<"ERROR: "<< message[E] << endl; exit(1);

}

Демонстративно - тестирующая программа:

#include <conio.h>

#include <iostream.h>

#include <fstream.h>

#include "tmatr.cpp"

int main()

{

clrscr();

Matrix<double> A(3,3), B(3,3), C(3,3);

Matrix<double> V(3),X(3),H(3),U(3);

double d;

A(0,0)=1.1; A(0,1)=2.2; A(0,2)=3.3;

A(1,0)=2.4; A(1,1)=1.1; A(1,2)=4.4;

A(2,0)=1.3; A(2,1)=2.1; A(2,2)=4.1;

B(0,0)=2; B(0,1)=7; B(0,2)=2;

B(1,0)=4; B(1,1)=8; B(1,2)=1;

B(2,0)=6; B(2,1)=4; B(2,2)=1;

V(0)=2.1; V(1)=3.31; V(2)=1.4;

H(0)=1.1; H(1)=2.1; H(2)=3.1;

//******************************

C=A+B;

cout<<"A:\n"<<A<<endl;

cout<<"B:\n"<<B<<endl;

cout<<"C=A+B:\n"<<C<<endl;

cout<<"Press any key .\n";

getch();

clrscr();

//******************************

C=A-B;

cout<<"A:\n"<<A<<endl;

cout<<"B:\n"<<B<<endl;

cout<<"C=A-B:\n"<<C<<endl;

cout<<"Press any key .\n";

getch();

clrscr();

//******************************

//******************************

X=V+H;

cout<<"V:\n"<<V<<endl;

cout<<"H:\n"<<H<<endl;

cout<<"X=V+H:\n"<<X<<endl;

cout<<"Press any key .\n";

getch();

clrscr();

//******************************

X=V-H;

cout<<"V:\n"<<V<<endl;

cout<<"H:\n"<<H<<endl;

cout<<"X=V-H:\n"<<X<<endl;

cout<<"Press any key .\n";

getch();

clrscr();

C=A*V;

cout<<"A:\n"<<A<<endl;

cout<<"V:\n"<<V<<endl;

cout<<"C=A*V:\n"<<C<<endl;

cout<<"Press any key .\n";

getch();

clrscr();

//******************************

Matrix<int> D(3,3), E(3,3);

D(0,0)=1; D(0,1)=2; D(0,2)=3;

D(1,0)=2; D(1,1)=5; D(1,2)=6;

D(2,0)=7; D(2,1)=3; D(2,2)=9;