АиПА / include / dalmat

/*-------------------------------------------------------------------------------------*/
/* Библиотека VP/C++, модуль DALMAT.H (линейная алгебра). Версия 2009.08 */
/* Пинчук В.П. Запорожье, vpinchuk@zntu.edu.ua */
/* Печатать Courier New Cyr, Size = 10, Rihgt Margin = 89, Print Margin = 3 */
/*-------------------------------------------------------------------------------------*/
#include <syst.h>

class dvector;
class dmatrix;
class ftable;
typedef dvector (*vfun)(dvector);

/* ---------------------Прототипы внешних перегруженных операций ----------------------*/

dmatrix operator+(const dmatrix& A, const dmatrix& B);
dmatrix operator-(const dmatrix& A, const dmatrix& B);
dmatrix operator*(const dmatrix& A, const dmatrix& B);
dmatrix operator*(double p, const dmatrix& B);
dmatrix operator*(const dmatrix& A, double p);
dvector operator*(const dmatrix& A, const dvector& X);
dmatrix operator/(double e, const dmatrix& D);
dmatrix operator/(const dmatrix& A, const dmatrix& B);
dvector operator+(const dvector& A, const dvector& B);
dvector operator-(const dvector& A, const dvector& B);
double operator*(const dvector& A, const dvector& B);

/*------------------------Прототипы внешних функций и процедур ------------------------*/

double amax(const dmatrix& A);
double amax(const dvector& A);
void gauss(const dmatrix& A, const dvector& B, dvector& X);
double polinom(dvector& a, double x);
dvector interpolinom(dvector& x, dvector& y);
dvector polinappr(ftable F, int p);
int newton(vfun system, double eps, double h, dvector& x);

/*-------------------------------------------------------------------------------------*/

/*------------------------------------ Класс dmatrix ----------------------------------*/
class dmatrix
{ public:
int n,m;
double** r;
dmatrix() { n=m=0; r=0; }
dmatrix(int);
dmatrix(int,int);
dmatrix(double**, int, int);
dmatrix(const dmatrix&);
~dmatrix();
dmatrix& operator=(const dmatrix&);
dmatrix& operator=(double);
double* operator[](int);
dmatrix operator~();
dmatrix& operator>>(FILE*);
dmatrix& operator<<(FILE*);
double det();
void rand(double, double);
};
/*-------------------------------- Функции класса dmatrix -----------------------------*/
dmatrix::dmatrix(int N)
{ int i,j;
n=N; m=N;
r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=0.0;
}
dmatrix::dmatrix(int N, int M)
{ int i,j;
n=N; m=M;
r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=0.0;
}
dmatrix::dmatrix(double** A, int N, int M = 0)
{ int i,j;
n=N;
if (M==0) m=N; else m=M;
r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=A[i][j];
}
dmatrix::dmatrix(const dmatrix& B)
{ int i,j;
n=B.n; m=B.m;
r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=B.r[i][j];
}
dmatrix::~dmatrix()
{ for (int i=0;i<n;i++) delete[] r[i];
delete[] r;
}
dmatrix& dmatrix::operator=(const dmatrix& B)
{ if (this==&B) return *this;
int i,j;
if (n) { for (i=0;i<n;i++) delete[] r[i];
delete[] r;
}
if (B.n) { n=B.n; m=B.m;
r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=B.r[i][j];
}
else { n=m=0; r=0; }
return *this;
}
dmatrix dmatrix::operator~()
{ dmatrix R(m,n);
int i,j;
for (i=0;i<n;i++) for (j=0;j<m;j++) R.r[j][i]=r[i][j];
return R;
}
dmatrix& dmatrix::operator=(double u)
{ if (n!=m) throw "dmatrix::operator=(double) : matrix must be square!";
int i,j;
for (i=0;i<n;i++)
for (j=0;j<n;j++) { if (i==j) r[i][j]= u;
else r[i][j]= 0.0;
}
return *this;
}
double* dmatrix::operator[](int i)
{ if (i<0 || i>=n) throw "function dmatrix::operator[](int) : illegal index";
return r[i];
}
dmatrix& dmatrix::operator>>(FILE* f)
{ fprintf(f,"%4d %4d \n",n,m);
int i,j;
for (i=0;i<n;i++)
{ for (j=0;j<m;j++) fprintf(f,"%15.8e ",r[i][j]);
fprintf(f,"\n");
}
return *this;
}
dmatrix& dmatrix::operator<<(FILE* f)
{ int i,j;
if (n) { for (i=0;i<n;i++) delete[] r[i];
delete[] r;
}
fscanf(f,"%d %d",&n,&m);
if (n) { r= new double*[n];
for (i=0;i<n;i++) r[i]= new double[m];
for (i=0;i<n;i++)
for (j=0;j<m;j++) fscanf(f,"%lf",&r[i][j]);
}
else { n=m=0; r=0; }
return *this;
}
void dmatrix::rand(double a, double b)
{ int i,j;
for (i=0;i<n;i++) for (j=0;j<m;j++) r[i][j]=frand(a,b);
}
FILE* operator<<(FILE* f, const dmatrix& B)
{ fprintf(f,"%4d %4d \n",B.n,B.m);
int i,j;
for (i=0;i<B.n;i++)
{ for (j=0;j<B.m;j++) fprintf(f,"%g ",B.r[i][j]);
fprintf(f,"\n");
}
return f;
}
double dmatrix::det()
{ if (n!=m) throw "dmatrix::det(): Not a square matrix in expression!";
int i,j,k,l;
double Q, D=1.0;
double** A= new double*[n];
for (i=0;i<n;i++) A[i]= new double[n];
for (i=0;i<n;i++) for (j=0;j<n;j++) A[i][j]=r[i][j];
for (k=0;k<n-1;k++)
{ l=k;
for (i=k+1;i<n;i++) if (abs(A[i][k]) >= abs(A[l][k])) l=i;
if (l==k && A[k][k]==0.0) return 0.0;
if (l!=k) { D=-D; swp(A[k],A[l]); }
if (A[k][k]==0.0) return 0.0;
for (i=k+1;i<n;i++)
{ Q=A[i][k]/A[k][k];
for (j=k+1;j<n;j++) A[i][j]-=Q*A[k][j]; }
}
for (i=0;i<n;i++) D*=A[i][i];
for (i=0;i<n;i++) delete[] A[i];
delete[] A;
return D;
}
/*-------------------------------------- Класс dvector --------------------------------*/
class dvector
{ public:
int m;
double* r;
dvector() { m=0; r=0; }
dvector(int);
dvector(int,double*);
dvector(const dvector&);
~dvector() { delete[] r; }
dvector& operator=(const dvector&);
dvector operator-();
double& operator[](int);
dvector& operator>>(FILE*);
dvector& operator<<(FILE*);
double length();
dvector& rand(double, double);
};
/*-------------------------------- Функции класса dvector -----------------------------*/
dvector::dvector(int N)
{ m=N;
r= new double[m];
for (int i=0;i<m;i++) r[i]=0.0;
}
dvector::dvector(int N, double* A)
{ m=N;
r= new double[m];
for (int i=0;i<m;i++) r[i]=A[i];
}
dvector::dvector(const dvector& B)
{ m=B.m;
r= new double[m];
for (int i=0;i<m;i++) r[i]=B.r[i];
}
dvector& dvector::operator=(const dvector& B)
{ if (this==&B) return *this;
int i;
if (m) delete[] r;
if (B.m) { m=B.m;
r= new double[m];
for (i=0;i<m;i++) r[i]=B.r[i];
}
else { m=0; r=0; }
return *this;
}
dvector dvector::operator-()
{ dvector A(*this);
for (int i=0;i<m;i++) A.r[i]= -A.r[i];
return A;
}
double& dvector::operator[](int k)
{ if (k<0 || k>=m) throw "dvector::operator[](int) : invalid index";
return r[k];
}
dvector& dvector::operator>>(FILE* f)
{ fprintf(f,"%4d \n",m);
for (int i=0;i<m;i++) fprintf(f,"%6.3f ",r[i]);
fprintf(f,"\n");
return *this;
}
dvector& dvector::operator<<(FILE* f)
{ if (m) delete[] r;
fscanf(f,"%d",&m);
if (m) { r= new double[m];
for (int i=0;i<m;i++) fscanf(f,"%lf",&r[i]);
}
else { m=0; r=0; }
return *this;
}
double dvector::length()
{ double L=0;
for (int i=0;i<m;i++) L+=sqr(r[i]);
L=sqrt(L);
return L;
}
dvector& dvector::rand(double a, double b)
{ int i;
for (i=0;i<m;i++) r[i]=frand(a,b);
return *this;
}

/*-------------------------------------- Класс ftable ---------------------------------*/
class ftable
{ public:
int n;
double *x, *y;
ftable() { n=0; x=y=NULL; }
ftable(int, double*, double*);
ftable(dvector&, dvector&);
ftable(const ftable&);
~ftable() { delete[] x, delete[] y; }
ftable& operator=(const ftable&);
ftable& operator>>(FILE*);
ftable& operator<<(FILE*);
};
/*--------------------------------- Функции класса ftable -----------------------------*/
ftable::ftable(int N, double* X, double* Y)
{ n=N;
x= new double[n]; y= new double[n];
for (int i=0;i<n;i++) { x[i]=X[i]; y[i]=Y[i]; }
}
ftable::ftable(dvector& X, dvector& Y)
{ if (X.m!=Y.m) throw "ftable: Invalid Parameters";
n=X.m;
x= new double[n]; y= new double[n];
for (int i=0;i<n;i++) { x[i]=X[i]; y[i]=Y[i]; }
}
ftable::ftable(const ftable& T)
{ n=T.n;
x= new double[n]; y= new double[n];
for (int i=0;i<n;i++) { x[i]=T.x[i]; y[i]=T.y[i]; }
}
ftable& ftable::operator=(const ftable& T)
{ if (this==&T) return *this;
delete[] x; delete[] y;
n=T.n;
x= new double[n]; y= new double[n];
for (int i=0;i<n;i++) { x[i]=T.x[i]; y[i]=T.y[i]; }
return *this;
}
ftable& ftable::operator>>(FILE* f)
{ fprintf(f,"%3d\n",n);
for (int i=0;i<n;i++) fprintf(f,"%19.12le %19.12le\n",x[i],y[i]);
return *this;
}
ftable& ftable::operator<<(FILE* f)
{ delete[] x; delete[] y;
fscanf(f,"%d",&n);
x= new double[n]; y= new double[n];
for (int i=0;i<n;i++) fscanf(f,"%le %le",&x[i],&y[i]);
return *this;
}

/* ----------------------------- Внешние перегруженные операции -----------------------*/

dmatrix operator+(const dmatrix& A, const dmatrix& B)
{ if (A.n != B.n || A.m != B.m) throw "operator+(dmatrix,dmatrix) : invalid operand!";
dmatrix C(A.n,A.m);
int i,j;
for (i=0;i<C.n;i++) for (j=0;j<C.m;j++) C.r[i][j]=A.r[i][j]+B.r[i][j];
return C;
}
dmatrix operator-(const dmatrix& A, const dmatrix& B)
{ if (A.n != B.n || A.m != B.m) throw "operator-(dmatrix,dmatrix) : invalid operand!";
dmatrix C(A.n,A.m);
int i,j;
for (i=0;i<C.n;i++) for (j=0;j<C.m;j++) C.r[i][j]=A.r[i][j]-B.r[i][j];
return C;
}
dmatrix operator*(const dmatrix& A, const dmatrix& B)
{ if (A.m != B.n) throw "operator*(dmatrix,dmatrix): invalid operand!";
dmatrix C(A.n,B.m);
int i,j,k;
for (i=0;i<C.n;i++)
for (k=0;k<C.m;k++) for (j=0;j<A.m;j++) C.r[i][k]+=A.r[i][j]*B.r[j][k];
return C;
}
dmatrix operator*(double p, const dmatrix& B)
{ dmatrix C(B.n,B.m);
int i,k;
for (i=0;i<C.n;i++)
for (k=0;k<C.m;k++) C.r[i][k]=p*B.r[i][k];
return C;
}
dmatrix operator*(const dmatrix& A, double p)
{ dmatrix C(A.n,A.m);
int i,k;
for (i=0;i<C.n;i++)
for (k=0;k<C.m;k++) C.r[i][k]=A.r[i][k]*p;
return C;
}
dvector operator*(const dmatrix& A, const dvector& X)
{ if (A.m != X.m) throw "operator*(dmatrix,dvector): invalid operand!";
dvector Y(A.n);
int i,j;
for (i=0;i<Y.m;i++) for (j=0;j<A.m;j++) Y.r[i]+=A.r[i][j]*X.r[j];
return Y;
}
dmatrix operator/(double e, const dmatrix& D)
{ if ( D.n!=D.m) throw "operator/(int,dmatrix): matrix is not square!";
char* mes = "operator/(int,dmatrix): Determinant of matrix = 0!";
int i,j,k,l, n=D.n; double R,m,aa;
dmatrix A(D), B(n,n);
for (i=0;i<n;i++) B.r[i][i]=1.0;
for (k=0;k<n-1;k++)
{ m=0.0;
for (i=k;i<n;i++) { aa=abs(A.r[i][k]);
if (m<aa) { m=aa; l=i; }
}
if (m==0.0) throw mes;
if (k!=l) { swp(A.r[k],A.r[l]); swp(B.r[k],B.r[l]); }
R=A.r[k][k];
for (j=k+1;j<n;j++) A.r[k][j]/=R;
for (j=0; j<n;j++) B.r[k][j]/=R;
for (i=k+1;i<n;i++)
{ R=A.r[i][k];
if (R!=0.0) { for (j=k+1;j<n;j++) A.r[i][j]-=A.r[k][j]*R;
for (j=0; j<n;j++) B.r[i][j]-=B.r[k][j]*R;
}
}
}
if (A.r[n-1][n-1]==0.0) throw mes;
for (j=0;j<n;j++) B.r[n-1][j]/=A.r[n-1][n-1];
for (k=n-1;k>0;k--)
for (i=k-1;;i--) { R=A.r[i][k];
if (R!=0.0) for (j=0;j<n;j++) B.r[i][j]-=B.r[k][j]*R;
if (i==0) break;
}
if (e!=1.0) for (i=0;i<n;i++) for (j=0;j<n;j++) B.r[i][j]*=e;
return B;
}
dmatrix operator/(const dmatrix& A, const dmatrix& B)
{ return A*(1/B);
}
dvector operator+(const dvector& A, const dvector& B)
{ if (A.m!=B.m) throw "operator+(dvector,dvector): invalid operands!";
int i, m=A.m;
dvector C(m);
for (i=0;i<m;i++) C.r[i]=A.r[i]+B.r[i];
return C;
}
dvector operator-(const dvector& A, const dvector& B)
{ if (A.m!=B.m) throw "operator+(dvector,dvector): invalid operands!";
int i, m=A.m;
dvector C(m);
for (i=0;i<m;i++) C.r[i]=A.r[i]-B.r[i];
return C;
}
double operator*(const dvector& A, const dvector& B)
{ if (A.m!=B.m) throw "operator*(dvector,dvector): invalid operands!";
int i, m=A.m;
double R=0.0;
for (i=0;i<m;i++) R+=A.r[i]*B.r[i];
return R;
}

/*------------------------------------- Внешние функции -------------------------------*/

double amax(const dmatrix& A)
{ int i,j;
double x, max=abs(A.r[0][0]);
for (i=1;i<A.n;i++) for (j=0;j<A.m;j++) { x=abs(A.r[i][j]); if (max<x) max=x; }
return max;
}
/*-------------------------------------------------------------------------------------*/
double amax(const dvector& A)
{ double x, max=abs(A.r[0]);
for (int i=1;i<A.m;i++) { x=abs(A.r[i]); if (max<x) max=x; }
return max;
}
/*-------------------------------------------------------------------------------------*/
void gauss(const dmatrix& A, const dvector& B, dvector& X)
{ if (A.n!=A.m || X.m!=B.m || X.m!=A.m)
throw "gauss(dmatrix,dvector,dvector): invalid dimensions of arrays!";
char* mes= "gauss(dmatrix,dvector,dvector): Determinant = 0!";
int i,j,k,l, n=X.m;
dmatrix R(n,n+1);
for (i=0;i<n;i++) for (j=0;j<n;j++) R.r[i][j]=A.r[i][j];
for (i=0;i<n;i++) R.r[i][n]=B.r[i];
double Q;
for (k=0;k<n-1;k++)
{ l=k;
for (i=k+1;i<n;i++) if (abs(R.r[i][k])>=abs(R.r[l][k])) l=i;
if (l==k && R.r[k][k]==0.0) throw mes;
if (l!=k) swp(R.r[k],R.r[l]);
if (R.r[k][k]==0.0) throw mes;
for (i=k+1;i<n;i++)
{ Q=R.r[i][k]/R.r[k][k];
for (j=k+1;j<=n;j++) R.r[i][j]-=Q*R.r[k][j];
}
}
if (R.r[n-1][n-1]==0.0) throw mes;
X.r[n-1]=R.r[n-1][n]/R.r[n-1][n-1];
for (k=n-2;;k--)
{ Q=0;
for (j=k+1;j<n;j++) Q+=X.r[j]*R.r[k][j];
X.r[k]=(R.r[k][n]-Q)/R.r[k][k];
if (k==0) break;
}
}
/*-------------------------------------------------------------------------------------*/
double polinom(dvector& a, double x)
{ int k, n=a.m;
double R= a[n-1];
for (k=n-2;k>=0;k--) R=R*x+a[k];
return R;
}
/*-------------------------------------------------------------------------------------*/
dvector interpolinom(dvector& x, dvector& y)
{ if (x.m!=y.m) throw "polincoef: invalid parameters";
int i,j, n= x.m;
dmatrix a(n,n);
dvector c(n);
for (i=0;i<n;i++) for (j=0;j<n;j++) a.r[i][j]=pow(x[i],j);
gauss(a,y,c);
return c;
}
/*-------------------------------------------------------------------------------------*/
dvector polinappr(ftable F, int p)
{ int i,j,k, n=F.n, m=p+1;
dvector a(m), b(m);
dmatrix g(m,m);
double S;
for (i=0;i<m;i++)
for (j=0;j<m;j++)
{ S=0.0;
for (k=0;k<n;k++) S+= pow(F.x[k],i+j);
g.r[i][j]=S;
}
for (i=0;i<m;i++)
{ S=0.0;
for (k=0;k<n;k++) S+= F.y[k]*pow(F.x[k],i);
b[i]=S;
}
gauss(g,b,a);
return a;
}
/*-------------------------------------------------------------------------------------*/
int newton(vfun system, double eps, double h, dvector& x)
{ const int Nitmax= 1000;
dvector B(x.m),F0(x.m),F1(x.m),dx(x.m);
dmatrix P(x.m);
double hh,dxm,xo;
int i,j, N=x.m, Nit=0;
hh=2*h;
do { B=system(x); B=-B;
for (j=0;j<N;j++) { xo=x[j];
x[j]=xo-h;
F0=system(x);
x[j]=xo+h;
F1=system(x);
x[j]=xo;
for (i=0;i<N;i++) P.r[i][j]=(F1[i]-F0[i])/hh;
}
gauss(P,B,dx);
dxm=abs(dx.r[0]); for (i=1;i<N;i++) if (dxm<abs(dx.r[i])) dxm=abs(dx.r[i]);
x=x+dx;
Nit++; errhalt(Nit>Nitmax,"Process is not approximate");
}
while (dxm>eps);
return Nit;
}
/*-------------------------------------------------------------------------------------*/