Red de conocimiento informático - Aprendizaje de código fuente - Programación de aspectos

Programación de aspectos

Los siguientes archivos son algunas operaciones de operaciones matriciales. La última función, EquationResolution, se puede utilizar para resolver el problema de mínimos cuadrados. Por supuesto, antes del cálculo, es necesario construir la matriz de coeficientes y la matriz constante mencionadas anteriormente, que en realidad son dos matrices.

// 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_)