Programación de aspectos
// Matrix.hpp
#If! definido(_matrix calcular_HPP__include_)
# definir _matrix calcular_HPP__INCLUDED_
# if _MSC_VER>1000
p>#Nota miscelánea una vez
# endif //_ MSC _ VER & gt; 1000
# incluir & ltmath.h & gt
Clase CMatrixCalculate
{
Público :
////Encuentra el valor determinante de la matriz, donde n es la dimensión.
línea de cálculo doble (matriz doble *, int n)
{
línea doble = 0
int i=0, j=0, k = 0;
int p=0, q = 0;
Si (n==1)
Matriz de retorno [0] ;
Otros
{
doble * tr = (doble *)calloc((n-1)*(n-1), sizeof(doble) );
for(k = 0; k & ltn; k++)
{
p = 0;
for(I = 0;i<n;i++)
{
if (i!=0)
{
q = 0; p>
for(j = 0; j & ltn; j++)
{
if (j!=k)
{
tr[p *(n-1)+q]=matriz[I * n+j];
q++;
}
}
p++;
}
}
liner+=matriz[k]*pow(-1,k)* CalculateLiner( tr, n-1);
}
Gratis(tr);
Retorno de línea;
}
}
////Encuentra el cofactor algebraico de la fila I y la columna J de la matriz, donde n es la dimensión.
cofactor de cálculo doble(doble * matriz, int i, int j, int n)
{
int x=0, y = 0;
p>
int p=0, q = 0;
Si (n==1)
Devuelve matriz [0];
Otros
{
doble * tr = (doble *)calloc((n-1)*(n-1), sizeof(doble));
p = 0;
for(x = 0; x & ltn; x++)
{
si (x!=i)
{
q = 0;
for(y = 0; y & ltn; y++)
{
Si (y ! =j)
{
tr[p *(n-1)+q]=matriz[x * n+y];
q++;
}
}
p++;
}
}
doble cc =pow(-1,i+j)*CalculateLiner(tr,n-1);
Gratis(tr);
Devolver cc;
}
}
////Transposición de matriz, matrizAT=(matrizA)T, m, n son el número de filas y columnas de la matrizA.
void CalculateAT(double *matrixA, double *matrixAT, int m, int n)
{
for(int I = 0;i<m; i++)
{
for(int j = 0; j & ltn; j++)
{
matriz en[j * m+ I]= matriz a[I * n+j];
}
}
}
//// Multiplicación de matrices , matrizAB=matrizA*matrizB, I, j son las filas y columnas de la matrizA, j, k son las filas y columnas de la matrizB.
void CalculateAB(doble *matrizA, doble *matrizB, doble *matrizAB, int i, int j, int k)
{
for(int m = 0; m & ltk; m++)
{
para(int n = 0; n & ltk; n++)
{
matriz ab[m * k+n]= 0;
for(int s = 0; s & ltj; s++)
{
matriz ab[m * k+n]+= matriz a[m * j+s]* matriz b[s * k+n];
}
}
}
}
////matriz ATA =(matrixa)t * matriz a, m, n son las filas y columnas de la matriz a respectivamente.
void calcular ATA(doble * matriz a, doble * matrizATA, int m, int n)
{
doble * en =(doble *)calloc ((m)*(n), tamaño de (doble));
CalcularATeAT(matrizA, en, m, n);
CalcularAB(en, matrizA, matrizATA, n, m, n);
Free (at);
}
////matrixA_ es la inversa de la matrizA, m es el orden.
void calcular a _(doble * matriz, doble * matrizA _, int m)
{
doble revestimiento = calcular revestimiento (matriz a, m) ;
for(int I = 0; i & ltm; i++)
{
for(int j = 0; j & ltm;j++)
matriz a _[j * m+I]= calcularcofactor(matriz a, I, j, m)/liner
}
}
/////////////////////////////////////////////// /// ////////////////////////////////
////Encontrar el momento inverso de la matriz definida positiva A, donde n es el orden.
int MatrixInversion(double *a, int n)
{
int i, j, k, m
Double w; , g, * b;
b = nuevo doble[n];
for(k = 0; k & lt= n-1; k++)
{
w = a[0];
w = a[0]+1.0e-15;
/*
if(fabs(w)+1.0 == 1.0)
{
Eliminar b;
printf(" fail \ n ");
retorno(-2);
}
*/
m = n-k-1;
for(I = 1;i<= n-1;i++)
{
g = a[I * n];
b[I]= g /w ;
si (i& lt= m)
b[I]=-b[I];
for(j = 1; j & lt= I；j++)
a[(I-1)* n+j-1]= a[I * n+j]+g * b[j];
}
a[n * n-1]= 1.0/w;
for(I = 1;i<= n-1;i++)
a[ (n-1)* n+I-1]= b[I];
}
for(I = 0;i<= n- 2; i++)
for(j = I+1; j & lt= n-1; j++)
a[I * n+j]= a[j * n +I];
Eliminar b;
Volver a (2);
}
////Encontrar la matriz definida positiva A Momento inverso, donde n es el orden.
void MatInversion(double *a, int n)
{
int i, j, k;
for(k = 0;k<n;k++)
{
for(I = 0;i<n;i++)
{
si (i! = k)*(a+I * n+k)=-*(a+I * n+k)/(*(a+k * n+k));
}
*(a+k * n+k)= 1/(*(a+k * n+k));
for(I = 0;i& ltn ;i++)
{
si (i! = k)
{
for(j = 0; j & ltn; j++)
{
Si (j!= k)*(a+I * n+j)+= *(a+k * n+j)* *(a +I * n+ k);
}
}
}
for(j = 0; j & ltn; j++ )
{
Si (j! = k)*(a+k * n+j)* = *(a+k * n+k);
}
}
}
/*Subrutina de inversión de matriz (buena)*/
int inverse _ matriz( double * m 1, int n)
{
int *is, *js
int i, j, k, l, u, v
Temperatura dual max_v;
is =(int *)malloc(n * sizeof(int));
js =(int *)malloc( n * sizeof(int));
if(is==NULL||js==NULL)
{
printf("¡Memoria insuficiente!\ n ");
return(0);
}
for(k = 0; k & ltn; k++)
{
max _ v = 0.0
for(I = k;i<n;i++)
{
for(j = k; j & ltn; j++)
{
temp = fabs(m 1[I * n+j]);
if(temp & gt; max_v)
{
max _ v = tempis[k]= I; js[k]= j;
}
}
}
if(max_v==0.0)
{
Gratis (sí); gratis (js); ¡La inversa no está disponible! \ n ");
return(0);
}
si (es [k]!=k)
{
for(j = 0; j & ltn; j++)
{
u = k * n+j = es[k]* n; +j;
temperatura = m 1[u]; m m 1[u]= m 1[v];
}
if(js[k]!=k)
for(I = 0;i<n;i++)
{
u = I * n+k; v = I * n+js[k];
temp = m 1[u]; 1[v]=t
emp;
}
l = k * n+k;
m 1[l]= 1,0/m 1[l];
for(j = 0; j & ltn; j++)
{
if (j!=k)
{
u = k * n+j;
m 1[u]* = m 1[l]
}
}
for(I = 0;i<n;i++)
{
si (i !=k)
{
for(j = 0; j & ltn; j++)
{
if (j!=k)
{
u = I * n+j;
m 1[u]-= m 1[I * n+k]* m 1[k * n+j];
}
}
}
}
para(I = 0;i<n;i++)
{
Si (I!=k)
{
u = I * n+k;
m 1[u ]* =- m 1[l];
}
}
}
for(k = n-1;k & gt=0 ;k -)
{
if(js[k]!=k)
for(j = 0;j & ltn; j++)
{
u = k * n+j; v = js[k]* n+j
temp = m 1[u] ;m 1[; u]= m 1[v]; m 1[v]= temp;
}
si (es [k]!=k)
para (I = 0;i<n;i++)
{
u = I * n+k v = I * n+is[k];
p>temperatura = m 1[u]; m 1[u]= m 1[v]; m 1[v]= temp
}
}
Gratis (sí); gratis (js);
Devolver (1);
}
//// Encuentra la ecuación matricial El mínimo solución de cuadrados de matrizA*matrizX=matrizL, donde myn son el número de filas y columnas de la matrizA respectivamente.
resolución de ecuación nula(doble * matriz a, doble *matrizL, doble *matrizX, int m, int n)
{
Si (m & ltn )retorno;
doble * en =(doble *)malloc((m)*(n)* tamaño de(doble));
doble * ATA =(doble *)malloc ((n)*(n)* tamañode(doble));
doble * atl =(doble *)malloc((n)* tamañode(doble));
CalcularATA (matrizA, ATA, m, n);
MatrixInversion(ata, n
CalculATeAT(matrizA, at, m, n
CalcularAB); (en, matrizL, atl, n, m, 1);
CalcularAB(ata, atl, matrizX, n, n, 1);
Libre(en); p>
Gratis (ATA);
Gratis (atl);
}
}
#endif / /! Definido(_Matrix_HPP__Contains_)