Visualizar matrices en pantalla

Muestra Matices en la salida estandar

type 
   tDimension = 1..100;
   eMatriz(f,c: tDimension) = array [1..f,1..c] of real;
   
   tRango = record
      f,c: tDimension value 1;
   end;
   
   tpMatriz = ^eMatriz;


procedure EscribirMatriz(var m: tpMatriz);
var filas,col : integer;
begin
   for filas := 1 to m^.f do begin
      for col := 1 to m^.c do
         write(m^[filas,col]:7:2);
      writeln(resultado);
      writeln(resultado)
     end;    
end;

Division matrices en pascal

División de dos matrices en pascal.
Para el uso de este procedmiento son necesarios los siguientes procedimientos.
Matriz Inversa
Multiplicar matrices

Dado la siguiente declaración de tipos:
type
tDimension = 1..100;
eMatriz(f,c: tDimension) = array [1..f,1..c] of real;

tRango = record
f,c: tDimension value 1;
end;

tpMatriz = ^eMatriz;


procedure Dividir(m1, m2: tpMatriz; var resul: tpMatriz);
var inversa: tpMatriz;
begin
{ Calcular inversa de m2 }
new (inversa, m2^.f, m2^.c);
MatrizInversa(m2,inversa);

Multiplicar(m1,inversa,resul);
end;

Matriz inversa en pascal

Para El uso de este procedimiento es necesario otros artículos de este blog como:
Determinante en pascal
Matriz Adjunta en pascal

Dada la siguiente declaración de tipos:

type 
   tDimension = 1..100;
   eMatriz(f,c: tDimension) = array [1..f,1..c] of real;
   
   tRango = record
      f,c: tDimension value 1;
   end;
   
   tpMatriz = ^eMatriz;


procedure MatrizInversa(m: tpMatriz; var resul: tpMatriz);
var i,j,i2,j2: integer; 
    adjunta: tpMatriz;
    deter: real;
begin
   deter:= Determinante(m);
   if(deter <> 0) then begin
   {Crea la matriz Adjunta}
   new (adjunta, m^.c -1, m^.f -1);
   
   for i:=1 to m^.f do
      for j:=1 to m^.c do
        begin
          AdjuntoMatriz(m,i,j,adjunta);
          resul^[i,j] := Determinante(adjunta); 
        end;  
      
   MatrizTraspuesta(resul);  
   { dividir determinante }
   for i2:=1 to m^.f do
      for j2:=1 to m^.c do
         resul^[i2,j2]:= resul^[i2,j2] / deter; 
   end;
end;

Traspuesta matriz en pascal

Este procedimiento realiza la matriz traspuesta a una dada.
La Matriz traspuesta se obtiene intercambiando las filas por las columnas
de una matriz.

Dado la declaración en la sección de tipos:

type
tDimension = 1..100;
eMatriz(f,c: tDimension) = array [1..f,1..c] of real;

tpMatriz = ^eMatriz;

Y las variables:

var
pM1, pM2, pResul: tpMatriz;
procedure MatrizTraspuesta(var resul: tpMatriz);
 var i,j,i2,j2: integer;
 mAux:tpMatriz;  {Matriz axuliar}
begin
 {Crear matriz m copia de resul}
 new (mAux, resul^.f, resul^.c);

 for i2:= 1 to mAux^.f do
    for j2:=1 to mAux^.c do
       mAux^[i2,j2] := resul^[i2,j2];
    
 { copia de la matriz resul }          
 for i:= 1 to mAux^.f do
    for j:=1 to mAux^.c do
       resul^[i,j] := mAux^[j,i];

end;

Determinante de matrices en pascal

Primero un poco de Teoría. Aprende a realizar el determinante de una matriz de
cualquier dimesión.

Sea A una matriz cuadrada y a_ij (con i y j como filas y columnas del array) uno cualquiera de sus elementos. Si se suprime la fila i y la columna j de la matriz A se obtiene una submatriz (o matriz adjunta) M_ij que recibe el nombre de matriz adjunta del elemento a_ij.

Dada la matriz

la matriz adjunta del elemento a₁₁ es la matriz que resultante de suprimir la fila 1 y columna 1 en la matriz A, es decir:

Llamamos menor complementario del elemento a_ij al determinante de la matriz complementaria del elemento a_ij , y se representa por a_ij

Se llama adjunto de a_ij , y se representa por por A_ij, al número (–1)^i+ja_ij.

El determinante de una matriz cuadrada es igual a la suma de los elementos de una fila o columna cualquiera, multiplicados por sus adjuntos.

Por ejemplo, si desarrollamos un determinante de orden n por los adjuntos de la 1ª fila se tiene:

Cálculo del determinante de una matriz.

El determinante de la matriz en este código se calcula por adjuntos mediante
dos procedimientos que se llaman de forma recursiva.

Dado la declaración en la sección de tipos:

type
tDimension = 1..100;
eMatriz(f,c: tDimension) = array [1..f,1..c] of real;

tpMatriz = ^eMatriz;

Y las variables:

var
pM1, pM2, pResul: tpMatriz;



El procedimiento AdjuntoMatriz devuelve la matriz adjunta a la fila (f) 
y columna (c) indicadas.


procedure AdjuntoMatriz(m: tpMatriz; f,c: integer; var resul: tpMatriz);
var i,j,i2,j2: integer value 0;
begin
i2 := 0;
for i:= 1 to m^.f do begin
if (i <> f) then begin  {Comprobar si la fila no es la que se va a elminar}
i2 := i2  +1;
for j:= 1 to m^.c do
   if (j <> c) then begin {Comprobar si la columna no es la que se va a eliminar}
      j2 := j2 +1;
      resul^[i2,j2] := m^[i,j] * (-1) pow(i+j);
   end;
end;
j2:= 0;
end;
end;

La función determinante calcula el determinante de la matriz de forma
recursiva y por adjuntos.

function Determinante(m: tpMatriz):real;
var
j:integer value 0;
det:real;
m2: tpMatriz;
begin
new(m2,m^.f -1,m^.c -1);
if m^.c = 2 then

{ Determinante de dos por dos, caso base de la recursividad }

  Determinante := m^[1,1] * m^[2,2] - m^[1,2] * m^[2,1]
else
begin
det:= 0;
for j:= 1 to m^.c do
begin
{Calcula los adjuntos de la fila 1. LLama al procedimiento Adjunto
Matriz que devuelve la matriz adjunta a la fila primera y a la columna j}
AdjuntoMatriz(m,1,j,m2);
{LLamada recursiva de la funcion Determinante}
 det:= det +  m^[1,j] * Determinante(m2);
end;
Determinante:= det;
end;
end;

Operaciones con matrices

Suma resta y multiplicación de matrices en pascal.

Para el uso de estos procedimientos es necesario declarar el tipo
tMatriz. Este tipo es un registro en el que f y c son las filas y columnas
de la matriz y datos es una matriz de numeros reales.

const
 N = 10;

type
 tMatriz= record
 datos: array [1..N,1..N] of real;
        f,c: 0..N;
    end;



Tarea: Suma de dos matrices
El procedimiento recibe dos matrices y devuelve la matriz sumada.


procedure Sumar(m1, m2: tMatriz; var resul: tMatriz);
var i,j:integer;
begin
      if (m1.c = m2.c) and (m1.f = m2.f) then begin
          resul.c:=m1.c;    { Crear Matriz resul del mismo rango que m1 y m2 }
          resul.f:=m2.c;
          for i:=1 to m1.c do
    for j:=1 to m1.f do
                        begin
                         resul.datos[i,j]:= m1.datos[i,j] + m2.datos[i,j];
                        end;
          end
       else writeln('No se pueden sumar matrices de diferente dimension');
end;



Tarea: Resta de dos matrices
El procedimiento recibe dos matrices y devuelve la matriz restada.


procedure Restar(m1, m2: tMatriz; var resul: tMatriz);
var i,j:integer;
begin
if (m1.c = m2.c) and (m1.f = m2.f) then begin
resul.c:=m1.c;    { Crear Matriz resul del mismo rango que m1 y m2 }
          resul.f:=m2.c;
          for i:=1 to m1.c do
                    for j:=1 to m1.f do
                     begin
                      resul.datos[i,j]:= m1.datos[i,j] - m2.datos[i,j];
                     end;
          end
       else writeln('No se pueden restar matrices de diferente dimension');
end;


Tarea: Multiplicación dos matrices
El procedimiento recibe dos matrices y devuelve la matriz multiplicada.


procedure Multiplicar(m1, m2: tMatriz; var resul: tMatriz);
var i,j:integer;
begin
        if (m1.c = m2.f) then begin
          resul.c:=m1.f;    { Crear Matriz resul de rango apropiado para multiplicar }
          resul.f:=m2.c;
          for i:=1 to m1.c do
                    for j:=1 to m1.f do
                     begin
                      resul.datos[i,j]:=resul.datos[i,j] + m1.datos[i,j] *
m2.datos[i,columna];
                     end;
end
       else writeln('No se pueden multiplicar matrices de esta dimension');
end;