Tuve que escribir un programa de multiplicación de matrices como una tarea hace unos 20 años. El código C a continuación, uno de mis primeros programas en C, permite al usuario ingresar dos matrices, calcula los resultados e imprime en la consola. Las matrices se almacenan en matrices procesadas utilizando bucles anidados. Busque la función disp_ans_mat .
#include
#definir MIN 1
#define MAX 10
/ * Prototipos de funciones. * /
- Cómo imprimir todo el historial de revisiones en Google Docs sin abrir cada revisión e imprimir ese documento específico / cronometrado
- ¿Cambiaría la tarifa de impresión si hubiera imágenes e ilustraciones en unas pocas páginas o no importa siempre que sea el mismo número de páginas?
- ¿Cmyk imprime lo mismo en todas las impresoras digitales?
- ¿Desde qué país podemos importar papel de copiadora de tamaño A4?
- ¿Cómo se controla la impresión de dinero? ¿Qué pasará si algún país puede imprimir el dinero que quiera?
vacío principal (vacío);
nulo mat_sizes (nulo);
inicialización nula (nula);
valores nulos de mat (int mat1_c, int mat1_r, int mat2_c, int mat2_r);
valores de ent_mat_nulo nulos (int * mat_ptr, int mat_c, int mat_r, int mat_no);
void mat_calc (int mat1_r, int mat2_r, int ans_mat_c, int ans_mat_r);
void disp_ans_mat (int ans_mat_c, int ans_mat_r);
int read_int (int dummy_int, int high, int low);
nulo salir (nulo);
/ * Declaraciones de matriz global. * /
int mat1 [MAX] [MAX];
int mat2 [MAX] [MAX];
int ans_mat [MAX] [MAX];
/ * Declaraciones de funciones. * /
vacío principal (vacío)
/ * Esta función forma el programa principal.
Pre: El usuario elige una opción, de acuerdo con el menú.
Publicación: se le ofrece al usuario el menú nuevamente, luego de la ejecución del programa,
hasta que se elija la opción B. * /
{
char c;
pone (“Este programa multiplica 2 matrices”);
printf (“hasta un tamaño máximo de% dx% d elementos. \ n”, MAX, MAX);
hacer
{
put (“\ nLas opciones disponibles son; – \ n”);
pone (“A: Para multiplicar 2 matrices”);
pone (“B: Para salir del programa. \ n”);
printf (“Opción de entrada:”);
scanf (“% c”, & c);
c = toupper (c);
interruptor (c)
{
caso (‘A’): {
mat_sizes ();
descanso;
}
caso (‘B’): {
dejar ();
descanso;
}
defecto : {
pone (“\ nERROR. Elija una opción que se muestre”);
descanso;
}
}
}
while (c! = ‘B’);
regreso;
}
nulo mat_sizes (nulo)
/ * Esta función permite la entrada y validación de los tamaños.
de las 2 matrices.
Pre: Se eligió la opción A en la función main.
Post: se establecen los tamaños de las 2 matrices y la función mat_values es
llamado. * /
{
int mat1_c, mat1_r, mat2_c, mat2_r;
mat1_c = mat1_r = mat2_c = mat2_r = 0;
inicializar ();
hacer
{
put (“\ nIntroduzca tamaños de matriz; – \ n”);
pone (“Matriz 1”);
pone (“——— \ n”);
printf (“No. de filas:”);
scanf (“% d”, & mat1_r);
mat1_r = read_int (mat1_r, MIN, MAX);
printf (“No. de columnas:”);
scanf (“% d”, & mat1_c);
mat1_c = read_int (mat1_c, MIN, MAX);
pone (“\ nMatriz 2.”);
pone (“——— \ n”);
printf (“No. de filas:”);
scanf (“% d”, & mat2_r);
mat2_r = read_int (mat2_r, MIN, MAX);
printf (“No. de columnas:”);
scanf (“% d”, & mat2_c);
mat2_c = read_int (mat2_c, MIN, MAX);
if (mat1_c! = mat2_r)
printf (“\ nERROR. Los tamaños de matriz no son válidos. \ n”);
}
while (mat1_c! = mat2_r);
valores_ mat (mat1_c, mat1_r, mat2_c, mat2_r);
regreso;
}
inicialización nula (nula)
/ * Esta función inicializa las matrices.
Pre: ninguno.
Publicación: las matrices ahora están establecidas en 0. * /
{
int col, fila;
col = fila = 0;
para (fila = 0; fila <MAX; fila ++)
{
para (col = 0; col <MAX; col ++)
{
mat1 [fila] [col] = 0;
mat2 [fila] [col] = 0;
ans_mat [fila] [col] = 0;
}
}
regreso;
}
valores_vacío nulos (int mat1_c, int mat1_r, int mat2_c, int mat2_r)
/ * Esta función controla la entrada de valores en las 2 matrices llamando
la función ent_mat_values dos veces.
Pre: La función mat_sizes ha realizado.
Publicación: las 2 matrices contienen valores definidos por el usuario y la función mat_calc
se llama. * /
{
int * mat1_ptr, * mat2_ptr;
int ans_mat_c, ans_mat_r, mat_no;
/ * Punteros establecidos para apuntar a direcciones de matriz. * /
mat1_ptr = & mat1 [0] [0];
mat2_ptr = & mat2 [0] [0];
ans_mat_c = ans_mat_r = mat_no = 0;
put (“\ nIntroduzca los valores de la matriz; – \ n”);
/ * Punteros a las direcciones de matriz pasadas a la función mat_values para evitar
duplicación. * /
mat_no ++;
valores_ent_mat (mat1_ptr, mat1_c, mat1_r, mat_no);
printf (“\ n”);
mat_no ++;
valores_ent_mat (mat2_ptr, mat2_c, mat2_r, mat_no);
ans_mat_c = mat2_c;
ans_mat_r = mat1_r;
mat_calc (mat1_r, mat2_r, ans_mat_c, ans_mat_r);
regreso;
}
void ent_mat_values (int * mat_ptr, int mat_c, int mat_r, int mat_no)
/ * Esta función, usando puntero-aritmética, permite la entrada de valores
en la matriz requerida.
Pre: Esta función recibe el tamaño de la matriz requerida. La dirección
de la matriz se recibe como un puntero.
Publicación: la matriz recibida ahora contiene valores definidos por el usuario. * /
{
int col, ent_int, i, fila;
col = ent_int = fila = 0;
i = 1;
printf (“Matriz% d. \ n”, mat_no);
pone (“——— \ n”);
para (fila = 0; fila <mat_r; fila ++)
{
para (col = 0; col <mat_c; col ++)
{
printf (“Valor% 3d:”, i);
scanf (“% d”, & ent_int);
/ * Validación y asignación de entrada del usuario. * /
ent_int = read_int (ent_int, -10000, 10000);
* (mat_ptr ++) = ent_int;
i ++;
}
/ * Mat_ptr se movió a la siguiente fila en la matriz. * /
mat_ptr + = (MAX – mat_c);
}
regreso;
}
void mat_calc (int mat1_r, int mat2_r, int ans_mat_c, int ans_mat_r)
/ * Esta función, usando subíndice-aritmética, calcula la multiplicación
de las 2 matrices.
Pre: Las 2 matrices que se multiplicarán, mat1 y mat2, se configuran según sea necesario
en términos de tamaños y valores.
Publicación: La matriz de respuestas, ans_mat, se calcula y funciona disp_ans_mat
se llama. * /
{
int i, j, k;
i = j = k = 0;
para (i = 0; i <mat1_r; i ++)
{
para (j = 0; j <ans_mat_r; j ++)
{
para (k = 0; k <mat2_r; k ++)
ans_mat [j] [i] + = (mat1 [j] [k] * mat2 [k] [i]);
}
}
disp_ans_mat (ans_mat_c, ans_mat_r);
regreso;
}
void disp_ans_mat (int ans_mat_c, int ans_mat_r)
/ * Esta función muestra la matriz calculada.
Pre: La función que mat_calc ha realizado.
Publicar: se muestra la matriz calculada y el control vuelve a
función principal. * /
{
int col, fila;
col = fila = 0;
pone (“\ nLa respuesta es; – \ n”);
para (fila = 0; fila <ans_mat_r; fila ++)
{
printf (“(“);
para (col = 0; col <ans_mat_c; col ++)
printf (“% 5d”, ans_mat [fila] [col]);
printf (“) \ n”);
}
regreso;
}
int read_int (int dummy_int, int low, int high)
/ * Esta función valida la entrada de enteros.
Pre: La entrada entera, junto con sus límites de límites, son recibidos por
la función.
Publicación: la entrada entera, ahora validada, se devuelve a la llamada
función. * /
{
while ((dummy_int alto))
{
printf (“\ nERROR. Entre% d a% d:”, bajo, alto);
scanf (“% d”, & dummy_int);
printf (“\ n”);
}
return (dummy_int);
}
nulo dejar (nulo)
/ * Esta función finaliza el programa.
Pre: La opción B se selecciona en la función main.
Publicación: el programa finaliza. * /
{
char c;
printf (“\ nPresione cualquier tecla para salir:”);
scanf (“% c”, & c);
printf (“\ n”);
regreso;
}
El código puede estar un poco pasado de moda pero aún debe compilarse.
