Código de creación de matrices de diccionario
# include & ltiostream & gt
# include & ltcstdlib & gt
# include & ltcstdio & gt
# include & ltcmath & gt
# include & ltcstring & gt
Usar espacio de nombres std
Determinante de categoría
{
Público:
Determinante()
{
int i, j;
p>
longitud lateral = 2;
matriz = new double *[longitud lateral];
for(I = 0;i<side length;i++)
{
matriz[I]= nuevo doble[longitud lateral];
}
for(I = 0;i<side length; i++)
{
for(j = 0; j & lt longitud del lado; j++)
{
array[ I][j ]= 0;
}
}
}
Determinante (múltiplo entero)
{
int i,j;
This->sideLenth = sideLenth
array = new double *[side lenth];
for( I = 0; i & lt longitud del lado; i++)
{
matriz[I]= new double[longitud del lado];
}
for(I = 0; i & lt longitud del lado; i++)
{
for(j = 0; j & lt longitud del lado ;j++)
{
matriz[I][j]= 0;
}
}
}
~Determinante()
{
for(int I = 0; i & lt longitud del lado; i++)
{
Eliminar[]matriz[I];
}
Eliminar[]matriz;
}
determinante de conjunto nulo() ;
doble cálculo();
doble signo igual();
Doble * * matriz;
int getsideLenth();
double calCofactor(int m, int n); //m es la escala horizontal y n es la escala vertical.
void show(); //para probar
Protegido:
int sideLenth
Privado:
double cal two();
copia nula(determinante y ampforCal);
void exchangeCorOrRow(determinante y ampforCal, int m, int n, bool colorrow); p>};
int determinante::getsideLenth()
{
Devuelve la longitud del lado;
}
determinante vacío::setdeterminant()
{
for(int j = 0; j & lt longitud del lado; j++)
{
for(int I = 0; i & lt longitud del lado; i++)
{
CIN & gt; p>
}
}
}
Doble determinante::calcular()
{
if(longitud del lado==2)
{
return cal two();
}
doble resultado = 0.0;
for(int i = 0;i< longitud del lado;i++)
{
resultado+=calCofactor(i, 0 )* matriz[I][0 ];
}
Devuelve el resultado;
}
Doble determinante::calCofactor( int m, int n)
{
int yi=0, yj = 0;
int I;
Determinante yzs (sideLenth-1);
for(I = 0; i & lt longitud del lado; i++)
{
si (i!=m)
{
for(int j = 0; j & lt longitud del lado; j++)
{
if (j!=n )
yzs matriz[yi][yj++]= matriz[I][j];
}
yi++;
yj = 0; p>}
}
doble tmp = yzs . calcular();
if((m+n) %2==1)
tmp =-tmp;
Devolver tmp
}
Doble determinante::caltwo()
{
if (ladoLenth! =2)
{
cout & lt& lt"¡Error!"& lt& ltendl
Devuelve 0.0;
}
Otros
{
Devolver matriz[0][0]*matriz[1][1]-matriz[0][1]*matriz[1][ 0];
}
}
Doble determinante::equal()
{
si ( sideLenth & lt; 4)
{
Devolver calcular();
}
Determinante paraCal(longitud del lado); p>
Copiar(for cal);
bool b = true
for(int I = 0; i & ltsideLenth-1; i++) // i son columnas que Es necesario triangularlos.
{
if(forCal.array[i][i]==0)
{
for(int k = I+1; k & lt longitud del lado; k++)
{
if(forCal.array[k][i]!=0)
{
intercambiar corrow(for cal, I, k, true);
b=! b;
Romper;
}
}
if(k = = longitud del lado)
Regresar 0;
}
for(int j = I+1; j & lt side length; J++) // j es la línea que necesita ser triangulada.
{
if(forCal.array[i][j]!=0)
{
veces dobles = forcal. matriz[I][j]/forcal . matriz[I][I];
for(int k = I; k & lt longitud del lado; k++)
{
para cal . array[k][j]-=(para cal . array[k][I]* veces);
}
}
}
}
resultado doble = 1
for(I = 0; i< longitud del lado; i++)
{
resultado * = forcal . matriz[I][I];
}
Si (!b) resultado = - resultado
p>Devolver resultados;
}
determinante nulo::copiar(determinante&forCal)
{
int i, j ;
if(forCal.sideLenth!=longitud del lado)
{
cout & lt& lt"Diferentes tamaños, no se pueden copiar"
Retorno;
}
for(I = 0; i< longitud del lado; i++)
{
for(j = 0; j & lt longitud del lado; j++)
{
forcal . }
}
}
void Determinante::exchangeCorOrRow(Determinante& ampforCal, int m, int n, bool colorrow)
{
Temperatura dual;
If (m & gt= sideLenth | | n & gt= sideLenth | | m & lt0 | | n & lt0)
{
cout & lt& lt"Error de parámetro"
Return
}
Si (colorrow)//true es intercambiar columnas; .
{
for(int I = 0; i< longitud del lado; i++)
{
temp = forcal . ][m];
para cal . matriz[I][m]= para cal .matriz[I][n];
forcal matriz[I][ n] = temp;
}
}
De lo contrario, //false es intercambiar líneas.
{
for(int I = 0; i< longitud del lado; i++)
{
temp = forcal . ][I];
para cal . matriz[m][I]= para cal .matriz[n][I];
forcal matriz[n][ I] = temp;
}
}
}
determinante nulo::show()
{
for(int i = 0; i & lt longitud del lado; i++)
{
for(int j = 0; j & lt longitud del lado longitud; j++)
{
printf("%-6.2lf ", matriz[j][I]);
}
printf(" \ n ");
}
}
Matriz de categorías
{
privado:
int row; //Valor máximo de la etiqueta de línea
int col //Valor máximo de la etiqueta de columna
void copyToDeterminant(Determinante y propósito (terreno);
void equalConvers(int rs, int rd, int cs, double factor);
void divider row(int r, int cs, double factor);
void exchangerow(int rs, int rd);
Público:
Matriz doble * *;
matriz(){ fila = 0; ; }
void setArray(); //Inicializa la matriz bidimensional
matrix(int row, int col);
~ Matrix( ) ;
void set array(); //Asigna un valor a la matriz
void show();
void inverse();
transporte vacío();
Multiplicación nula de amigos (matriz y resultado, suma de matriz constante.
faciend, matriz constante y multiplicador);
int stairlize(int start, int end);
int getrow(){ return row;}
int getcol (){ return col;}
};
matriz vacía::setArray()
{
int i, j;
matriz = new double *[fila];
for(I = 0; i<row;i++)
{
matriz[ I]= nuevo doble[col];
}
for(I = 0;i<coli++)
{
for(j = 0; j & lt fila; j++)
{
matriz[j][I]= 0;
}
}
}
matriz::matriz(int fila, int col)
{
Esto ->fila = fila
Esta ->col = col
setArray();
}
Matriz: :~matrix()
{
int I;
for(I = 0; i<i++)
{
Eliminar[ ]matriz[I];
}
Eliminar[]matriz;
matriz = NULL
}
matriz vacía::setmatrix()
{
if(row==0||col==0)
{
Lanza "Matriz no inicializada\n";
}
int i,j;
for( i = 0;i<coli++)
{
for(j = 0;j<coli++)
{
scanf("%lf ", & amparray[j][I]);
}
}
}
matriz vacía::show()
{
int i,j;
for(I = 0;i<coli++)
{
for(j = 0; j & lt fila; j++ )
{
printf("%.2lf ",matriz[j][I ]);
}
printf( " \ n ");
}
}
gap Multiplicar (resultado de matriz y amplificador, suma de matriz constante.
faciend, matriz constante y multiplicador)
{
if(faciend.row!=multiplicator.col)
lanza "El número de columnas de la matriz izquierda Debe ser igual al número de filas de la matriz derecha\n";
resultado. fila = multiplicador. fila;
resultado. col = faciend.col;
resultado.set array();
int times = faciend.row
int m, n, I
for(n = 0; n & lt resultado. fila; n++)
{
for(m = 0; m & lt resultado. col; m++)
{
número de resultado doble = 0.0;
for(I = 0;i<era;i++)
{
número de resultado+= faciend .array[I][ m]* multiplicador . matriz[n][I];
}
resultado .matriz[n][m]=número de resultado; /p>
}
}
matriz vacía::copyToDeterminant(destino determinante y amplificador)
{
if ( fila!=columna)
Lanzar "Solo cuando el número de filas y columnas de la matriz son iguales se puede copiar al determinante\n";
if (fila!=destino .getsideLenth())
Lanza "El tamaño determinante no coincide con la matriz\n";
int i,j;
for(I = 0 ; i & lt fila ; i++)
{
for(j = 0; j & ltcolj++)
{
matriz de destino[. I][j]= matriz[I][j];
}
}
}
matriz vacía: :transporte ()
{
if (filas!=columnas)
arroja "Invertible solo si el número de filas y columnas de la matriz son iguales\n " ;
Determinante tmp determinante(fila);
copyToDeterminant(tmpDeterminant);
valor doble = tmpdeterminant igual();
. If (valor == 0)
{
Printf("El valor del determinante es %lf, por lo que la matriz es irreversible\n ", valor);
Retorno;
}
int i, j;
for(I = 0; i<i++)
{
for(j = 0; j & ltcolj++)
{
array[j][I]= determinante tmp calco factor( I, j)/valor;
}
}
}
matriz vacía::inversa()
{
int i,j;
for(I = 0;i<col-1;I++)//coordenada de coordenadas
{
for(j = i+1;i<i++)//banner
{
doble tmp = matriz[j][I];
matriz [j][yo]
= matriz[I][j];
matriz[I][j]= tmp;
}
}
}
Voidmatrix:: convers iguales (int RS, int rd, int cs, double factor) // RS es la marca de la fila inicial ds, la fila de destino cs y la columna inicial.
{
for(int I = cs; i & lt fila; i++)
{
array[I][rd ]-= matriz[I][RS]*factor;
//printf(" matriz[% d][% d]= % . 2 lf ",I,rd,matriz[I][ rd]);
}
//printf(" \ n ");
}
matriz vacía::exchangerow( int rs, int rd)
{
for(int I = 0; i & lt fila; i++)
{
Doble tmp
tmp = matriz[I][RS];
Matriz[I][RS]=matriz[I][rd];
matriz [I][rd]= tmp;
}
}
matriz vacía::divideRow(int r, int cs, doble factor)
{
for(int I = cs; i & lt fila; i++)
{
matriz[I][r]/= factor;
}
}
int matriz::stairlize(int inicio, int fin)
{
int i, j;
Factor doble
int R = 0;
if(inicio & lt; 0 | | fin & gt= fila | inicio & gt fin)
{
cout & lt& lt"Parámetros de entrada incorrectos"
Devuelve 0;
}
for(I = inicio; i & lt=end; I++) // es un banner.
{
if(array[R][i]==0)
{
int k;
for(k = R+1; k & ltcolk++)
{
if(array[i][k])
{
exchangerow(i,k);
Romper;
}
}
if(k==col )
{
Continuar;
}
}
for(j = 0; j & ltcolj++ )
{
if(matriz[I][j]& & ampj!=R)
{
Factor = matriz [I][j]/array[I][R];
equalConvers(R, j, I, factor);
}
}
r++;
}
for(I = 0;i<= R;i++)
{
for(j = I; j & lt; j++)
{
if(array[j][i])
{
divideRow(i,j,array[j][I]);
Romper;
}
}
}
return R;
}
void main()
{
cout & lt& lt"Por favor selecciona la operación que deseas realizar"
cout & lt& lt"1. Evaluación de determinantes"
cout & lt& lt"2.Multiplicación de matrices"
cout & lt& lt"3. Matriz inversa de matriz"
cout & lt& lt"4. Transposición de matriz"
cout & lt& lt"5. Tipo de paso " < & ltendl
cout & lt& lt"0.Salir del programa"
intSelect;
Y (CIN>>Select)
{
Cambiar (selección)
{
Caso 1:
{
int size;
cout & lt& lt"Ingrese la dimensión del determinante a calcular"
CIN & gt;& gt tamaño;
Determinante jz (tamaño);
JZ . set determinante();
Printf("El valor de este determinante es %.2lf\n ", JZ . igual());
Romper;
}
Caso 2:
{
int rc, col, row//rc es el valor máximo de la fila y columna de la matriz A , col es el valor máximo de la columna de la matriz A y fila es el valor máximo de la fila de la matriz b.
cout & lt& ltPor favor ingrese el valor máximo del número de filas de la matriz A, el número de columnas de la matriz B, el número de columnas de la matriz A y el número de filas de la matriz B
CIN & gt; & gtrc & gt& gtcol & gt& gtrow;
Matriz A(rc, col);
Matriz B(fila, RC);
cout & lt& lt"Asigne un valor a la matriz A"
a set Matrix();
cout & lt& lt"Asigne un valor a la matriz b. "
b . establecer matriz();
Matriz C;
Multiplicación (C, A, B);
c . show();
Ruptura;
}
Caso 3:
{
int tamaño;
cout & lt& lt" Ingrese el tamaño del cuadrado"
CIN & gt;& gt size;
Inversión de matriz (tamaño, tamaño);
invertir .set matriz() ;
invertir .transporte();
invertir . p>
}
Caso 4:
{
int size;
cout & lt& lt"Por favor ingresa el tamaño del cuadrado"
CIN & gt ; & gt tamaño;
Inversión de matriz (tamaño, tamaño);
inversión . set matriz();
invertir .inverse();
p>
invertir .show();
Romper;
}
Caso 5:
{
int m, n, R;
cout & lt& lt"Ingrese el número de columnas y filas del matriz respectivamente"
CIN & gt;& gtm & gt& gtn;
Inversión de matriz (m, n);
inversión . set matriz();
R=inversing.stairlize(0, m-1);
cout & lt& lt"El rango de la matriz es"
inversing .show() ;
Pausa;
}
Caso 0:
Salir(0);
Pausa;
}
cout & lt& lt"Seleccione Nuevo tipo de cálculo"
}
}
/*
五
5 4
1 -2 2 -1 1
2 -4 8 0 2
-2 4 -2 3 3
3 -6 0 - 6 4
*/