No se que paso con el codigo que subi originalmente pero lo vuevo a subir

En el program
Main
using System;
using System.Collections.Generic;
using System.Text;

namespace CMatrices
{
class Program
{
static void Main(string[] args)
{
int[,] M1, M2, MR;
Double[,] Mres,Moriginal,Minversa;
int fila, columna, fila2, columna2;
String opc;
do
{

Console.WriteLine(" MENU ");
Console.WriteLine("1........................SUMA DE MATRICES");
Console.WriteLine("2........................RESTA DE MATRICES");
Console.WriteLine("3........................MULTIPLICACION DE MATRICES");
Console.WriteLine("4........................TRANSPOSICION DE MATRICES");
Console.WriteLine("5........................MATRIZ INVERSA");
Console.WriteLine("6........................MULTIPLICAR UNA MATRIZ POR UN ESCALAR");
Console.WriteLine("7........................SALIR");
Console.WriteLine("");
Console.Write("\nIngrese el digito de la opción que desea escoger: ");
opc = Console.ReadLine();
Console.Clear();
switch (opc)
{
case "1":
{
Console.Write("Numero de Filas: ");
fila = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas: ");
columna = Convert.ToInt32(Console.ReadLine());
M1 = new int[fila, columna];
M2 = new int[fila, columna];
MR = new int[fila, columna];
clsMatrices.CargaMatrices(M1, M2);
clsMatrices.SumaMatrices(M1, M2, MR);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(MR);
Console.ReadLine();
Console.Clear();

}
break;
case "2":
{
Console.Write("Numero de Filas: ");
fila = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas: ");
columna = Convert.ToInt32(Console.ReadLine());
M1 = new int[fila, columna];
M2 = new int[fila, columna];
MR = new int[fila, columna];
clsMatrices.CargaMatrices(M1, M2);
clsMatrices.RestaMatrices(M1, M2, MR);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(MR);
Console.ReadLine();
Console.Clear();

}
break;
case "3":
{
Boolean MsgValida;
do
{
Console.WriteLine("De la Matriz 1:");
Console.Write("Numero de Filas: ");
fila = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas: ");
columna = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("De la Matriz 2:");
Console.Write("Numero de Filas: ");
fila2 = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas: ");
columna2 = Convert.ToInt32(Console.ReadLine());
clsMatrices objMatriz = new clsMatrices();
MsgValida = objMatriz.ValidaMatrizMul(fila, columna, fila2, columna2);
if (MsgValida == true)
{
M1 = new int[fila, columna];
M2 = new int[fila2, columna2];
MR = new int[fila, columna2];
clsMatrices.CargaMatricesM1xN(M1);
clsMatrices.CargaMatricesM2xN(M2);
clsMatrices.MultiplicaMatrices(M1, M2, MR,fila,columna,columna2);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(MR);
Console.ReadLine();
Console.Clear();
}
else
{
Console.WriteLine("Error de Concepto");
Console.Clear();
}
} while (MsgValida != true);


}
break;
case "4":
{
Boolean MsgdeValidez;
do
{
Console.Write("Numero de Filas: ");
fila = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas: ");
columna = Convert.ToInt32(Console.ReadLine());
clsMatrices objMatriz2 = new clsMatrices();
MsgdeValidez = objMatriz2.ValidaMatrizTranspuesta(fila, columna);
if (MsgdeValidez == true)
{
M1 = new int[fila, columna];
MR = new int[fila, columna];
clsMatrices.CargaMatricesT(M1);
clsMatrices.CargaMatrizTraspuesta(M1, MR, fila, columna);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(MR);
Console.ReadLine();
Console.Clear();

}
else
{
Console.WriteLine("La Matriz que se quiere transponer debe ser una Matriz cuadrada");
Console.Clear();

}
} while (MsgdeValidez != true);



}
break;
case "5":
{
Double Determinante;
Console.WriteLine("Ingrese una Matriz Cuadrada de 2x2: ");
int Tamaño = 2;
Moriginal = new Double[Tamaño,Tamaño];
Mres=new Double[Tamaño,Tamaño];
Minversa = new Double[Tamaño, Tamaño];

clsMatrices.CargaMatricesMoriginal(Moriginal);
clsMatrices objMatriz = new clsMatrices();
Determinante= objMatriz.CalculaDeterminante(Moriginal);
if (Determinante != 0)
{
Console.WriteLine("La Matriz es inversible");
Console.ReadLine();
clsMatrices.InvierteMatriz(Moriginal, Mres);
clsMatrices.CalculaMatrizInversa(Mres, Minversa, Determinante);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(Minversa);
Console.ReadLine();
}
else
{
Console.WriteLine("La Matriz no es inversible");
Console.ReadLine();
}
Console.Clear();


}
break;
case "6":
{
int Escalar;
Console.Write("Numero de Filas de la Matriz: ");
fila = Convert.ToInt32(Console.ReadLine());
Console.Write("Numero de Columnas de la Matriz: ");
columna = Convert.ToInt32(Console.ReadLine());
Console.Write("Ingrese el Escalar que va a multiplicar ");
Escalar = Convert.ToInt32(Console.ReadLine());
M1 = new int[fila, columna];
MR = new int[fila, columna];
clsMatrices.CargaMatricesT(M1);
clsMatrices.CargaEscalarXMatriz(M1, MR, fila, columna, Escalar);
Console.WriteLine("El Resultado es:");
clsMatrices.MostrarMatrizResultado(MR);
Console.ReadLine();
Console.Clear();
}
break;
case "7":
{
opc = "7";
Console.WriteLine("Gracias por usar el Programa");
Console.ReadLine();
}
break;
default:
{
Console.WriteLine("La opcion que escogio no es valida");
Console.ReadLine();
Console.Clear();
}
break;
}

}while(opc!="7");









}
}
}

Y en la clase ClMatriz
using System;
using System.Collections.Generic;
using System.Text;

namespace CMatrices
{
class clsMatrices
{
int[,] A, B, C;
public clsMatrices()
{

}
public static void CargaMatrices(int[,] M1, int[,] M2)
{

for (int i = 0; i < M1.GetLength(0); i++)
{
for( int j=0 ; j < M1.GetLength(1) ; j++ )
{
Console.Write("\n Valor de la Matriz 1:[F{"+(i+1)+"},C{"+(j+1)+"}] :");
M1[i,j]=Convert.ToInt32(Console.ReadLine());
Console.Write("\n Valor de la Matriz 2: [F{"+(i+1)+"},C{"+(j+1)+"}] :");
M2[i, j] = Convert.ToInt32(Console.ReadLine());
}
}


}
public static void MostrarMatrizResultado(int[,] MR)
{
for (int i = 0; i < MR.GetLength(0); i++)
{
for (int j = 0; j < MR.GetLength(1); j++)
{
Console.WriteLine("F[{" + (i + 1) + "},C{" + (j + 1) + "}] : " + MR[i, j]);
}
}

}
public static void MostrarMatrizResultado(Double[,] Minversa)
{
for (int i = 0; i < Minversa.GetLength(0); i++)
{
for (int j = 0; j < Minversa.GetLength(1); j++)
{
Console.WriteLine("F[{" + (i + 1) + "},C{" + (j + 1) + "}] : " + Minversa[i, j]);
}
}

}
public static void SumaMatrices(int[,] M1, int[,] M2, int[,] MR)
{
for (int i = 0; i < M1.GetLength(0); i++)
{
for (int j = 0; j < M2.GetLength(1); j++)
{
MR[i, j] = M1[i, j] + M2[i, j];
}
}

}
public static void RestaMatrices(int[,] M1, int[,] M2, int[,] MR)
{
for (int i = 0; i < M1.GetLength(0); i++)
{
for (int j = 0; j < M2.GetLength(1); j++)
{
MR[i, j] = M1[i, j] - M2[i, j];
}
}

}
public Boolean ValidaMatrizMul(int Fila, int Columna, int Fila2, int Columna2)
{
Boolean mensaje;
if (Columna == Fila2)
{
Console.WriteLine("Se puede llevar acabo la multiplicación");
mensaje = true;
Console.ReadLine();


}
else
{
Console.WriteLine("No se puede llevar acabo la multiplicación");
mensaje = false;
Console.ReadLine();

}
return mensaje;
}
public static void CargaMatricesM1xN(int[,] M1)
{

for (int i = 0; i < M1.GetLength(0); i++)
{
for (int j = 0; j < M1.GetLength(1); j++)
{
Console.Write("\n Valor de la Matriz 1:[F{" + (i + 1) + "},C{" + (j + 1) + "}] :");
M1[i, j] = Convert.ToInt32(Console.ReadLine());

}
}


}
public static void CargaMatricesM2xN(int[,] M2)
{

for (int i = 0; i < M2.GetLength(0); i++)
{
for (int j = 0; j < M2.GetLength(1); j++)
{
Console.Write("\n Valor de la Matriz 2: [F{" + (i + 1) + "},C{" + (j + 1) + "}] :");
M2[i, j] = Convert.ToInt32(Console.ReadLine());
}
}


}
public static void MultiplicaMatrices(int[,] M1, int[,] M2, int[,] MR, int fila,int columna, int columna2)
{
for (int i = 0; i < fila; i++)
{
for (int j = 0; j < columna2; j++)
{
MR[i, j] = 0;
for (int K = 0; K {
MR[i, j] += M1[i, K] * M2[K, j];
}
}
}

}
public static void CargaMatricesT(int[,] M1)
{

for (int i = 0; i < M1.GetLength(0); i++)
{
for (int j = 0; j < M1.GetLength(1); j++)
{
Console.Write("\n Valor de la Matriz :[F{" + (i + 1) + "},C{" + (j + 1) + "}] :");
M1[i, j] = Convert.ToInt32(Console.ReadLine());

}
}


}
public Boolean ValidaMatrizTranspuesta(int Fila, int Columna)
{
Boolean mensaje;
if (Fila == Columna)
{
Console.WriteLine("Se puede obtener la matriz transpuesta");
mensaje = true;
Console.ReadLine();


}
else
{
Console.WriteLine("No se puede obtener la matriz transpuesta");
mensaje = false;
Console.ReadLine();

}
return mensaje;
}
public static void CargaMatrizTraspuesta(int[,] M1, int[,] MR, int fila, int columna)
{
for (int i = 0; i < fila; i++)
{
for (int j = 0; j < columna; j++)
{
MR[i, j] = M1[j, i];
}
}

}
public static void CargaMatricesMoriginal(Double[,] Moriginal)
{

for (int i = 0; i < Moriginal.GetLength(0); i++)
{
for (int j = 0; j < Moriginal.GetLength(1); j++)
{
Console.Write("\n Valor de la Matriz : [F{" + (i + 1) + "},C{" + (j + 1) + "}] :");
Moriginal[i, j] = Convert.ToDouble(Console.ReadLine());
}
}


}
public double CalculaDeterminante(Double[,] Moriginal )
{
Double Determinante;
Determinante = (Moriginal[0, 0] * Moriginal[1, 1])+((-1*(Moriginal[1,0]*(Moriginal[0,1]))));
return Determinante;

}
public static void InvierteMatriz(Double[,] Moriginal, Double[,] Mres)
{
Mres[0, 0] = Moriginal[1, 1];
Mres[1, 1] = Moriginal[0, 0];
Mres[0, 1] = -1*(Moriginal[0, 1]);
Mres[1, 0] = -1 * (Moriginal[1, 0]);

}
public static void CalculaMatrizInversa(Double[,] Mres, Double[,] Minversa, Double Determinante )
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
Minversa[i, j] =Mres[i,j]/Determinante;

}
}

}
public static void CargaEscalarXMatriz(int[,] M1, int[,] MR, int fila, int columna,int Escalar)
{
for (int i = 0; i < fila; i++)
{
for (int j = 0; j < columna; j++)
{
MR[i, j] = M1[i, j]*Escalar;
}
}

}


}

}

Santiago Feijó (Deber PIB)

Pronóstico del PIB desde el año 1993 hasta 2007

--Años desde 1993 hasta 2007
zt=[18573 20195 21268 23635 23255 16675 15934 21250 24899 28636 32642 37187 41763 45789 48508]';
q=length(zt)
zt1=[0;zt(1:q-1)]
zt2=[0;0;zt(1:q-2)]
zt3=[0;0;0;zt(1:q-3)]
x=[zt1,zt2,zt3,zt4]
c=inv(x'*x)*(x'*zt)
R=poly(0,'R')
R=R^2-c(1)*R-c(2)
rz=roots(R)
Alpha=real(rz(1))
Beta=imag(rz(1))
r=sqrt(Alpha^2+Beta^2)
Teta=acos(Alpha/r)
t=[1:q]';
z1=(r.^t).*cos(Teta*t)
z2=(r.^t).*sin(Teta*t)
X=[z1,z2]
a=inv(X'*X)*(X'*zt)
Z=a(1)*z1+a(2)*z2
plot2d(t,[zt Z])
t=[1:0.1:q]';
z1=(r.^t).*cos(Teta*t)
z2=(r.^t).*sin(Teta*t)
Z= a(1)*z1+a(2)*z2
plot2d(t,Z)

Primer proyeccion Gustavo Araujo 9no A

zt=[ 10056 18573 20195 21268 23635 23255 16675 15934 21250 24899 28636 32642 37187 41763 45789 48508]';

n=length(zt)
zt1=[0;zt(1:n-1)]
zt2=[0;0;zt(1:n-2)]
zt3=[0;0;0;zt(1:n-3)]
zt4=[0;0;0;0;zt(1:n-4)]
zt5=[0;0;0;0;0;zt(1:n-5)]
zt6=[0;0;0;0;0;0;zt(1:n-6)]
zt7=[0;0;0;0;0;0;0;0zt(1:n-7)]
x=[zt1,zt2,zt3,zt4,zt5,zt6;zt7]

b=inv(x'*x)*(x'*zt)
S=poly(0,'S')
S=S^2-b(1)*S-b(2)
raiz=roots(S)
alfa=real(raiz(1))
bet=imag(raiz(1))
r=sqrt(alfa^2+bet^2)
teta=acos(alfa/r)
t=[1:n]';
z1=(r.^t).*cos(teta*t)
z2=(r.^t).*sin(teta*t)
X=[z1,z2]
A=inv(X'*X)*(X'*zt)
Z=A(1)*z1+A(2)*z2
plot2d(t,[zt Z])
t=[1:0.1:n]';
z1=(r.^t).*cos(teta*t)
z2=(r.^t).*sin(teta*t)
Z= A(1)*z1+A(2)*z2
plot2d(t,Z)