Manipulación de Imágenes

FILTRO DE LA MEDIA

I =[25, 25, 25, 25, 25; 25, 128, 35, 35, 25; 25, 45, 35, 128, 25; 25, 25, 35, 25, 25]
[n,m]=size(I);
v = zeros(9,1);
for i=2:n-1
for j=2:m-1
v(1)= I(i,j);
v(2)= I(i-1,j);
v(3)= I(i-1,j+1);
v(4)= I(i,j-1);
v(5)= I(i,j);
v(6)= I(i,j+1);
v(7)= I(i+1,j-1);
v(8)= I(i+1,j);
v(9)= I(i+1,j+1);
sort(v)
I(i,j)=v(5)
end
end


FILTRO DE LA MEDIANA

I = [25, 25, 25, 25, 25; 25, 45, 35, 128, 25; 25, 45, 35, 35, 25; 25, 45, 35, 35, 25; 25, 25, 25, 25, 25]
[n,m]=size(I);
for i=2:n-1
for j=2:m-1
I(i,j)=fix((I(i-1,j-1)+I(i-1,j)+I(i-1,j+1)+I(i,j-1)+I(i,j)+I(i,j+1)+I(i+1,j-1)+I(i+1,j)+I(i+1,j+1))/9)
end
end

Aplicación de los Filtro de la Media y Mediana en imágenes.

1.- APLICANDO EL FILTRO DE LA MEDIA (En la matriz dada).

el código de la implementación en Scilab es:

M = [25, 25, 25, 25, 25;25,128,35,35,25;25,45,35,128,25;25,25,35,25,25]
[n,m]=size(M)
for i=2:n-1
for j=2:m-1
V = M(i-1:i+1,j-1)
V=[V,M(i-1:i+1,j)]
V=[V,M(i-1:i+1,j+1)]
sort(V)
M(i,j)=V(4)
end
end


2.- APLICANDO EL FILTRO DE LA MEDIANA(En la matriz dada)

el código de la implementación en Scilab es:

M = [25, 25, 25, 25, 25;25,45,35,35,35;25,45,35,35,25;25,45,35,35,25;25,25,25,25,25]
[n,m]=size(M)
for i=2:n-1
for j=2:m-1
M(i,j)=fix((M(i-1,j-1)+M(i-1+j)+M(i-1,j+1)+M(i,j-1)+M(i,j)+M(i,j+1)+M(i+1,j-1)+M(i+1,j)+M(i+1,j+1))/9)
end
end

IMAGENES DIGITALES

Una imagen digital, también llamada gráfico digital, es una representación bidimensional de una imagen utilizando bits (unos y ceros). Dependiendo de si la resolución de la imagen es estática o dinámica.

La imagen digital, bien sea generada por el ordenador o bien creada a través de algún instrumento de captura(cámara digital o un escáner)supone la traducción de los valores de luminosidad y color a un lenguaje que pueda entender el ordenador y los periféricos con él relacionados.

La presencia o no de movimiento en las imágenes digitales permite clasificarlas ante todo en dos grandes grupos: Imágenes De mapa de Bits e Imágenes vectoriales.

1. Imagenes de mapa de bits.

Es importante,saber cuánta información se asigna a cada píxel. Un píxel puede contener muchos valores (blanco y negro, grises, color, etc...). Esa es la base de la principal clasificación de las imágenes de mapa de bits.

1.1 Imágenes de 1 bit por píxel
1.2 Imágenes de escala de grises (8 bits por píxel).
1.3 Imágenes RGB o Lab (24 bits por píxel).
1.4 Imágenes CMYK (32 bits por píxel).
1.5 Imágenes en color de 8 bits o menos.


1.1 Imágenes de 1 bit por píxel. En este tipo de imágenes cada celdilla (píxel) sólo puede tener uno de dos valores: uno o cero. Como basta 1 bit para definir esa alternativa, se les llama “imágenes de 1 bit” (también se les llama “imágenes de mapa de bits, de alto contraste, o de línea”).
1.2 Imágenes de escala de grises (8 bits por píxel). Cada píxel puede tener 256 valores diferentes. Este es el modo de las imágenes digitales de blanco y negro “normales”.
1.3 Imágenes RGB o Lab (24 bits por píxel). Si se toma un píxel y se le asigna tres bytes, dispondremos de 24 bits en tres grupos de ocho. Podemos “colorearlo” siguiendo el sistema de color de los monitores de televisión, que se basan en tres “canales” de luz de color (Rojo, Azul y Verde). De este modo podemos distinguir hasta 16.777.216 millones de tonos de color ( 256 Rojo × 256 Azul × 256 Verde).
1.4 Imágenes CMYK (32 bits por píxel). Si a cada píxel le asignamos 4 bytes, podríamos representar (teóricamente) los valores CMYK propios de la cuatricromía profesional (1 byte para el cian, otro para el magenta, otro para el amarillo y un cuarto para el negro. Este formato es transparente al usuario de computadoras, ya que los monitores son RGB y no CMYK, como es el caso de la impresión profesional).
1.5 Imágenes en color de 8 bits o menos. Es lo que se llama color indexado. Lo que se hace es que se crea una tabla o índice de 256 colores y a cada uno de los posibles valores de un píxel se le asigna uno de ellos.

2. Las imágenes vectoriales.
Las imàgenes vectoriales se las obtiene mediante operaciones matemáticas. Es decir, en vez de trazar una retícula con miles o millones de puntos para trazar una línea, le damos a la máquina unas coordenadas x1 e y1 y le pedimos que trace una línea hasta otras coordenadas x2 e y2 .

3. Procesamiento de imágenes.
Entre los principales procesos que se llevan a cabo desde que se captura una imagen hasta su puesta a punto, podemos citar los siguientes:

3.1 Métodos para variar la información gráfica.
3.2 Métodos para variar el tamaño.
3.3 Las transformaciones.
3.4 La compresión.

3.1 Métodos para variar la información gráfica.
El análisis físico de una imagen se realiza con el histograma; una gráfica de barras que muestra el número de píxeles para cada nivel de grises. Los procesos de mejora de la imagen se basan fundamentalmente en los métodos para cambiar matemáticamente la información gráfica. Veamos, primero, tres formas en que puede manipularse la información de un histograma.
3.1.1 El barrido de desplazamiento (Slide Mapping) cambia la luminosidad a base de agregar o sustraer un valor constante. Por ejemplo; al añadir una constante de 50 a cada píxel de esta imagen, se desplaza el histograma hacia la derecha en 50 niveles de gris.
3.1.2 El barrido de extensión (Stretch Mapping) mejora los contrastes pobres a base de multiplicar o dividir cada píxel por una constante. La multiplicación “extiende” los valores del píxel, de modo que se puede utilizar una mayor gama de grises.
3.1.3 El barrido complementario (Complement Mapping) cambia el valor digital de cada píxel para invertir la imagen. Los píxeles negros se vuelven blancos. Los píxeles blancos se vuelven negros y los píxeles grises se convierten en sus complementarios.

3.2 Métodos para variar el tamaño.
La decimación es un proceso mediante el cual se eliminan píxeles para reducir el tamaño de una imagen. Para reducirla a la mitad, se eliminan filas y columnas de píxeles de forma alterna.

3.3 Las transformaciones.
Las transformaciones son tratamientos de cuadro que trasladan los datos de la imagen a otro espacio o dominio, para que puedan ser manipulados de forma más rápida.

3.4 La compresión.
“Compresión es la supresión de información redundante’’.
La compresión de las imágenes trata de aprovecharse de esta redundancia para reducir el número de bits necesarios para representar la imagen, consiguiendo de esta forma ahorrar recursos tanto de almacenamiento como de transmisión.

Hay dos técnicas de compresión de imágenes: reversibles (‘lossless’ o ‘noiseless’) e Irreversibles (‘lossy’ o ‘noisy’).
3.4.1 La compresión reversible quiere decir ‘sin pérdida’ y se refiere a que si se comprime una imagen y se almacena, cuando se recupera, la imagen obtenida coincide exactamente con la original hasta en el más pequeño detalle. En otras palabras, no se pierde información utilizando esta técnica de compresión.
3.4.2 La compresión irreversible quiere decir ‘con pérdida’ y se refiere a que se puede suprimir cierta información de la imagen para hacerla más pequeña y sin que el ojo note la diferencia o permitiendo perder pequeños detalles no significativos. Es decir, al volver a descomprimir la imagen se recupera con alguna pequeña diferencia respecto a la original.

Principales formatos en que se presenta un archivo de imagen digital estática.

BMP (Microsoft Windows Bitmap file)
CUR (Microsoft Windows Cursor file)
EPS (Encapsulated PostScript)
GIF (CompuServe Graphics Image Format file)
HDF (Hierarchical Data Format file)
ICO (Microsoft Windows Icon file)
JPG (Joint Photographic Experts Group)
WMF (Window Meta File )
PBM (Portable Bitmap file )
PGM (Portable Grayscale Map file )
PIC (PIXAR Picture file )
PCX (PC Paintbrush )
PICT (SoftImage PICT file )
PIX (Alias Pixel image file )
PNG (Portable Network Graphic )
PPM (Portable Pixel Map file )
PS (PostScript )
RAS (Sun Raster file )
RGB (Silicon Graphics RGB image file )
RGBa (4-component Silicon Graphics image file )
RGBA (4-component Silicon Graphics image file with generated alpha )
RLA (Wavefront raster image file )
RLE (Utah Runlength-encoded image file )
RPBM (Raw Portable Bitmap file )
RPGM (Raw Portable Grayscale Map file )
RPNM (Raw Portable any Map file )
RPPM (Raw Portable Pixel Map file )
SYNU (Synu image file )
TGA (Truevision Targa image file )
TIFF (Tagged Image File )
VIFF (Khoros Visualization Image File Format )
X (Stardent AVS X image file )
XBM (X11 Bit Map file )
XWD (X Window Dump image file )

4. CONCLUSIONES
La imagen digital es de fácil duplicación, y puede ser de acceso simultáneo. No gasta materiales en su producción y no hay que crear nuevos recursos de hardware que los que generalmente existen.
Es importante poner énfasis en lo que es la imagen digital por dentro, es decir, no solamente editar la imagen, sino también conocer qué mecanismos están operando en el interior de ese archivo.
La principal ventaja aportada la imagen digital es la estabilidad, mientras que la imagen fotográfica clásica sufren una degradación química con el paso del tiempo, que repercute en la calidad de dicha reproducción, los ceros y unos que componen una imagen digital permanecen estables, con lo que la imagen no variará a lo largo del tiempo.
Sobre las herramientas de diseño,el software de elección para la imagen en mapa de bits es Adobe Photoshop y Corel Draw para dibujo sectorial.

Imagen Digital

La Imagen Estática.

Las imágenes digitales estáticas se dividen en:
Imágenes vectoriales
De mapa de bits.

Las imágenes de mapa de bits.

Las imágenes se pueden representar mediante retículas de celdillas a las que vamos asignando valores. Este modo de “pintar” es la base de todas las imágenes impresas y de buena parte de las digitales.

Tipos de imágenes
Imágenes de 1 bit por píxel
Imágenes de escala de grises (8 bits por píxel).
Imágenes RGB o Lab (24 bits por píxel).
Imágenes CMYK (32 bits por píxel).
Imágenes en color de 8 bits o menos.

Las imágenes vectoriales.

Una forma muy distinta de formar una imagen es la de hacerlo mediante operaciones matemáticas. Podemos dibujar círculos, cuadrados, triángulos y miles de formas.

Las imágenes vectoriales de dos dimensiones suelen tener varias partes. Sólo el contorno y el relleno serán visibles al imprimir. Lo demás son instrumentos de trabajo. La base de estas operaciones son las llamadas “Curvas Bezier”.

Procesamiento de imágenes.

Para el tratamiento de una imagen digital se emplean diversos procederes y algoritmos que tienen en su trasfondo la aplicación de múltiples ecuaciones matemáticas. Estos métodos son generalmente transparentes al usuario común y son un principio básico de los grandes software que realizan este tipo de trabajo.

Métodos para el Procesamiento de Imagenes:

· Métodos para variar la información gráfica.
· Métodos para variar el tamaño.
· Las transformaciones.
· La compresión.
· La optimización.

Formatos de Compresión de Imágenes:

BMP	Microsoft Windows Bitmap file
CUR	Microsoft Windows Cursor file
EPS	Encapsulated PostScript
GIF	CompuServe Graphics Image Format file
HDF	Hierarchical Data Format file
ICO	Microsoft Windows Icon file
JPG	Joint Photographic Experts Group
WMF	Window Meta File
PBM	Portable Bitmap file
PGM	Portable Grayscale Map file
PIC	PIXAR Picture file
PICT	SoftImage PICT file
PNG	Portable Network Graphic
RGB	Silicon Graphics RGB image file
RGBa	4-component Silicon Graphics image file
RGBA	4-component Silicon Graphics image file with generated alpha
RPBM	Raw Portable Bitmap file
TIFF	Tagged Image File

Imagenes Digitales

Imagen Digital
Es una representación bidimensional de una imagen utilizando bits (unos y ceros). Dependiendo si la resolución de la imagen: estática o dinámica.
Bits: Un bit es la unidad de información que equivale a la elección de 0 ó 1 en la combinación de ellos se basa la información.
El Píxel: es el elemento más pequeño que forma la imagen, son las unidades de color de la imagen.
Una imagen digital, bien sea generada por el ordenador o bien creada a través de algún instrumento de captura, tal como una cámara o un escáner, supone la traducción de los valores de luminosidad y color a un lenguaje que pueda entender el ordenador y los periféricos con él relacionados, esto es, un lenguaje digital.

La principal ventaja aportada por este lenguaje es la estabilidad; mientras que la emulsión de una imagen fotográfica clásica sufren una degradación química con el paso del tiempo, que repercute en la calidad de dicha reproducción, los ceros y unos que componen una imagen digital permanecen estables, con lo que la imagen no variará a lo largo del tiempo.
Como se ha mencionado existen varias formas de obtención de imágenes entre las principales tenemos:
• Por medio de dispositivos de conversión analógica-digital como los escáneres y las cámaras digitales.
• Directamente mediante programas informáticos, como por ejemplo realizando dibujos con el ratón (informática) o mediante un programa de renderización 2D.
Las imágenes digitales se pueden modificar mediante filtros, añadir o suprimir elementos, modificar su tamaño, etc. y almacenarse en un dispositivo de grabación de datos como por ejemplo un disco duro.

Tipos de imagen

Se dividen en dos grandes grupos:

• Imágenes vectoriales: Es la información de cada uno de los puntos que se recoge en forma de ecuación matemática que lo relaciona con el resto de los puntos que forman la imagen.
Ventaja: La calidad de la imagen no varía al modificar el tamaño, ya que la información de cada punto no es absoluta sino relativa al resto de la imagen. Además, debido a su definición matemática apenas ocupa espacio, ya que una fórmula que represente su forma es suficiente para representar todos los puntos que la componen. Es el tipo adecuado para el diseño de línea y figura y no es soportado de forma directa por los programas navegadores de Internet.

• Imágenes de mapa de bits o bitmap: se construyen describiendo cada uno de los puntos que componen la imagen y llevan, por tanto, información acerca de la posición absoluta y el color de cada uno de ellos.
Cada uno de los puntos sería la tesela de un mosaico con sus propias características.
Ventaja: Permite recoger una amplísima gama tonal, por lo que es el tipo adecuado para representar imágenes captadas de la realidad. A cambio, la variación de tamaño supondrá modificaciones en la calidad, ya que el número de celdas que forman la imagen permanece invariable, por lo que un aumento del tamaño hace que el único recurso posible sea ampliar el tamaño de cada una de ellas.

Tipo de ficheros gráficos:

JPEG: Proporcionan un alto grado de compresión, así la imagen se puede transmitir de un modo más rápido a través de Internet. Es el formato propio de la fotografía digital. Sin transparencia.

GIF: No provoca ninguna pérdida de datos en la imagen aunque reduce la profundidad de color a 8 bits, lo que nos da un total de 256 colores. Permite realizar transparencias y animaciones.

PNG: Se trata de un formato con un alto grado de compresión y sin pérdidas. Dispone de alta profundidad de color.

BMP: Formato que corresponde a un mapa de bits sin comprimir con una profundidad de color de 24 bits.
El procesamiento digital de imágenes es el conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad o facilitar la búsqueda de información.
Fundamentos de imágenes digitales
Una imagen digital en escala de grises es un matriz de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en el determinado punto o pixel (picture element), por convención el origen de la imagen se encuentra en el extremo izquierdo superior.
Una imagen digital a colores esta formada por 3 matrices de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en cada una de las bandas espectrales del RGB (Rojo, Verde, Azul), de cada punto o pixel (picture element), a diferencia de las imágenes en escala de grises, las imágenes a color requiren de la combinación de las 3 bandas de color, para representar el color de un pixel.
Los filtros se utilizan para la modificación de imágenes ya sea para detectar los bordes de una escena o para modificar el aspecto, otra función de los filtros es para la eliminación de ruido de la imagen.

Bibliografía
http://www.Apendice%20H%20-%20Imagenes%20digitales
http://www.Imagen digital - Wikipedia, la enciclopedia libre.mht
http://www.Procesamiento digital de imágenes - Wikipedia, la enciclopedia libre
http://www.La imagen digital, una mirada interna
http://www.Las imágenes digitales ventajas e inconvenientes - Consejos foto - Hiboox

IMAGEN DIGITAL

Una imagen digital es una representación bidimensional de una imagen utilizando bits (unos y ceros).

En el caso de las imágenes cromáticas los parámetros que se deben considerar son los 256 niveles de gris a través de tres canales RGB (Red, Green, Blue). Estos son los tres colores primarios utilizados en mezcla aditiva.

Por otra parte, la imagen acromática es aquella que está compuesta por una escala tonal de grises cuyo rango varía de 2, tal como un dibujo en blanco y negro (1 bpp) hasta 256 (8 bpp). El parámetro bpp representa la cantidad de información con la que contamos y permite saber el número de valores que nos proporcionará una imagen.

TIPOS DE IMAGEN DIGITAL:

MAPA DE BITS:
Está compuesta por píxeles. Un píxel es una unidad de información de valores de color y luminosidad propios.

Características:

· Forma cuadrada
· Posición relativa al resto de píxeles de un mapa de bits.
· Profundidad de color (capacidad para almacenar color), que se expresa en bits.
· Si se cambia el tamaño pierde definición.

IMAGEN VECTORIAL:
Está compuesta por vectores que son ecuaciones matemáticas que definen una forma: un vértice, un contorno, un relleno, etc. Varios vectores componen las diferentes formas poligonales y colores de una imagen vectorial.

Característica:

· Se pueden escalar sin problemas de definición.

FORMATOS DE IMAGEN:

Entre los formatos más populares están:

BMP (gráfico/fotográfico sin compresión).-Es un formato de compresión sin pérdidas.
Admite cualquier tipo de resolución y una profundidad de color máxima de 24 bits.

GIF (gráfico/animaciones).- Es un formato que devuelve imágenes de tamaño muy reducido. Su profundidad de color máxima es de 8 bits.

JPG (fotográfico con compresión).- Es un formato de compresión con pérdidas. Admite modos en escala de grises con una profundidad de 8 bits y en color hasta 24 bits. No es un formato adecuado para imágenes con alto contraste de color.

Imágenes

IMAGEN DIGITAL

Una imagen digital en escala de grises es un matriz de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en el determinado punto o pixel (picture element), por convención el origen de la imagen se encuentra en el extremo izquierdo superior.

Una imagen digital a colores esta formada por 3 matrices de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en cada una de las bandas espectrales del RGB (Rojo, Verde, Azul), de cada punto o pixel (picture element), a diferencia de las imágenes en escala de grises, las imágenes a color requiren de la combinación de las 3 bandas de color, para representar el color de un pixel.

Por ejemplo, un determinado punto blanco de una imagen en escala de grises se describiría: P(x, y) = 255, sin embargo en una imagen a colores para describir el color del mismo punto se realizaría así: P(x, y) = (255, 255,255), esto debido a que el (0, 0,0) corresponde al negro absoluto y el (255, 255,255) al blanco absoluto).

PROCESAMIENTO DIGITAL DE IMÁGENES

El procesamiento digital de imágenes es el conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad o facilitar la búsqueda de información.
Las operaciones que se pueden realizar con imágenes se dividen en :
Operaciones de punto
Operaciones de entorno
Operaciones con dos o más imágenes

PRONOSTICOS DEL PIB (PATRICIO TAPIA)

--PRONOSTICO DEL PIB PARA EL 1998
--TOMANDO COMO VALORES REFERENCIALES LOS ANTERIORES AÑOS DESDE EL 1993 HASTA EL 1997
zt=[18573 20195 21268 23635 23255]';
n=length(zt)
zt1=[10056;zt(1:n-1)]
zt2=[0;10056;zt(1:n-2)]
x=[zt1,zt2]
b=inv(x'*x)*(x'*zt)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
z1=(raiz(1).^t)
z2=(raiz(2).^t)
x=[z1 z2]
a=inv(x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2
error1=zt-z
sqrt(error1'*error1)
plot(t,error1)
--EN LA SIGUIENTE LINEA SE DA EL PRONOSTICO DEL VALOR PARA EL 1998
t=[1:n+1]';
z1=(raiz(1).^t)

--EN CONCLUSION : EN VALOR RESULTADO DEL PRONOSTICO ES MUY ELEVADO Y DIFERENTE DEL VALOR –
--QUE SE ANUNCIO POR LA PRENSA.EN AQUELLA EPOCA DEBIDO A LOS FACTORES ADVERSOS POR TODOS
--CONOCIDOS .

===============================================

--PRONOSTICO DEL PIB PARA EL 2008
--TOMANDO COMO VALORES REFERENCIALES LOS ANTERIORES AÑOS DESDE EL 2000 HASTA EL 2007
zt=[21250 24899 28636 32642 37187 41763 45789 48508]';
n=length(zt)
zt1=[0;zt(1:n-1)]
zt2=[0;0;zt(1:n-2 )]
x=[zt1,zt2]
b=inv(x'*x)*(x'*zt)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
z1=(raiz(1).^t)
z2=(raiz(2).^t)
x=[z1 z2]
a=inv(x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2
error1=zt-z
sqrt(error1'*error1)
plot(t,error1)
--EN LA SIGUIENTE LINEA SE DA EL PRONOSTICO DEL VALOR PARA EL 2008
t=[1:n+1]';
z1=(raiz(1).^t)
z2=(raiz(2).^t)
z=a(1)*z1+a(2)*z2
plot(t,z)


==================================================================
==================================================================

OPERACIONES CON MATRICES (PATRICIO TAPIA)

PRIMER TRABAJO
1.1- ELABORAR UN PROGRAMA PARA OBTENER LA TRANSPUESTA, INVERSA Y EL DETERMINANTE DE UNA MATRIZ
1.2- ELABORAR UN PROGRAMA PARA REALIZAR OPERACIONES SUMA RESTA Y MULTIPLICACION ENTRE MATRICES


DESARROLLO

ELABORAR UN PROGRAMA PARA OBTENER LA TRANSPUESTA, INVERSA Y EL DETERMINANTE DE UNA MATRIZ

import java.io.*;

class lectura // para sacar la matriz transpuesta, inversa y el determinante
{

int mat[][], trans[][], f, c;
double deter=1.0;
double inv[][];
double n1,n2,n3,n4,n5,n6,n7,n8,n9;
double ind1,ind2,ind3;
double ecu[][], ecu2[],ecu3[][];
int op;

BufferedReader h;
void ini(){
h=new BufferedReader(new InputStreamReader(System.in));
}

int entero (String x) throws IOException{
int a=0;
System.out.print(x);
try {
a=Integer.parseInt(h.readLine());
} catch(NumberFormatException e) {
System.out.println("\tERROR: NO ES UN NUMERO");
}
return a;
}

double doble (String x) throws IOException{
double a=0;
System.out.print(x);
try {
a=Double.parseDouble(h.readLine());
} catch(NumberFormatException e) {
System.out.println("\tERROR: NO ES UN NUMERO");
}
return a;
}

void menu(int op) throws IOException {
matrices m=new matrices();
ini();
do {
System.out.println("\n\t\t\t M E N U ");
System.out.println(" ================================================================");
System.out.println(" [1] Matriz transpuesta");
System.out.println(" [2] Determinante de una matriz");
System.out.println(" [3] Matriz inversa");
System.out.println(" [4] Salir");
System.out.println();
op=entero("\tElige una opcion: ");
System.out.println();
switch(op) {
case 1:
//Matriz transpuesta
System.out.println("\tMatriz transpuesta");
f=entero("\tIngrese el numero de filas==> ");
c=entero("\tIngrese el numero de columnas==> ");
System.out.println();

mat=m.lee_M(f,c);
System.out.println("\tMATRIZ ORIGINAL");
System.out.println();
m.imp_M(mat);

System.out.println();
trans=m.transpuesta(mat,f,c);
System.out.println();
System.out.println("\tMATRIZ TRANSPUESTA");
System.out.println();
m.imp_M(trans);
/****************************************************/
break;

case 2:
//Determinante de una matriz
System.out.println();
System.out.println();
System.out.println("\tDeterminante de una matriz");
f=entero("\tIngrese el numero de filas y columnas==> ");
System.out.println();

mat=m.lee_M(f,f);
System.out.println("\tMATRIZ ORIGINAL");
System.out.println();
m.imp_M(mat);

System.out.println();
deter=m.determinate(mat,f);
System.out.println("\tDeterminante==> "+deter);
/****************************************************/
break;

case 3:
//Matriz inversa
System.out.println();
System.out.println();
System.out.println("\tMatriz inversa");
f=entero("\tIngrese el numero de filas y columnas==> ");
System.out.println();

mat=m.lee_M(f,f);
System.out.println("\tMATRIZ ORIGINAL");
System.out.println();
m.imp_M(mat);

System.out.println();
inv=m.inversa2(mat,f);
System.out.println("\tMATRIZ INVERSA");
System.out.println();
m.imp_M2(inv);


/****************************************************/
break;

case 4:
System.out.println("\tFin del programa");
break;

default:
System.out.println("\tOpcion errada!!!");
}
}
while(op!=4);
}
}







import java.io.*;

class matrices // para sacar la matriz transpuesta, inversa y el determinante
{

int[][] lee_M(int f, int c) throws IOException
{
lectura o4=new lectura();
o4.ini();
int matriz[][]=new int[1][1];
try {
matriz=new int[f][c];
for(int i=0; i {
for (int j=0; j {
matriz[i][j]=o4.entero("\tIngrese el elemento ["+i+"] ["+j+"]==> ");
}
System.out.println();
}
} catch (NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
return matriz;
}

void imp_M(int x[][])
{
try {
for(int i=0; i {
for (int j=0; j {
System.out.print("\t"+x[i][j]+" ");
}
System.out.println();
}
}catch(NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
}

void imp_M2(double x[][])
{
try {
for(int i=0; i {
for (int j=0; j {
System.out.print("\t"+x[i][j]+" ");
}
System.out.println();
}
}catch(NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
}

void imp_V(double x[])
{
try {
for(int i=0; i {
System.out.print("\t"+x[i]+" ");
}
System.out.println();
}catch(NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
}

//Matriz transpuesta

int[][] transpuesta(int x[][], int f, int c)
{
int resp[][]=new int[1][1];
try {
resp=new int[c][f];
for(int i=0; i {
for(int j=0; j {
resp[i][j]=x[j][i];
}
}
} catch (NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DEL VECTOR NEGATIVO");
}
return resp;
}
/****************************************************/


//Determinante de una matriz

double determinate(int x[][], int f)
{
try {
for(int k=0; k {
for(int i=k+1; i {
for(int j=k+1; j {
x[i][j]-=x[i][k]*x[k][j]/x[k][k];
}
}
}
}catch (NegativeArraySizeException e)
{
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
}


double deter=1.0;
for(int i=0; i {
deter*=x[i][i];
}
return deter;
}
/****************************************************/


//Matriz inversa double
double[][] inversa(double x[][], int f) {
double resp[][]=new double[1][1];
double resp2[][]=new double[1][1];

try {
resp=new double [f][f];
resp2=new double[f][f];

for(int i=0; i resp[i][i]=1.0;
}

for(int k=0; k for(int i=k+1; i for(int s=0; s resp[i][s]-=x[i][k]*resp[k][s]/x[k][k];
}
for(int j=k+1; j x[i][j]-=x[i][k]*x[k][j]/x[k][k];
}
}
}

for(int s=0; s resp2[f-1][s]=resp[f-1][s]/x[f-1][f-1];
for(int i=f-2; i>=0; i--){
resp2[i][s]=resp[i][s]/x[i][i];
for(int k=f-1; k>i; k--){
resp2[i][s]-=x[i][k]*resp2[k][s]/x[i][i];
}
}
}
}catch (NegativeArraySizeException e) {
System.out.println("\tERROR: TAMANO DE LA MATRIZ NEGATIVO");
}
return resp2;
}
/****************************************************/


public static void main(String args[]) throws IOException
{
matrices o=new matrices();
lectura o2=new lectura();

o2.ini();

o2.menu(o2.op);
}
}


==================================
==================================

//1.2 ELABORAR UN PROGRAMA PARA REALIZAR OPERACIONES SUMA RESTA Y MULTIPLICACION ENTRE MATRICES

public class MenuMatriz // para operaciones de suma y resta y multiplicación de matrices del orden que se escoja.

{
public static void main(String args[])
{
Operaciones obj= new Operaciones();
Leer Lee = new Leer();
int op;
do
{
System.out.println("\n M E N U ");
System.out.println("=========================");
System.out.println(" [1] SUMA");
System.out.println(" [2] RESTA");
System.out.println(" [3] MULTIPLICACCION");
System.out.println(" [4] SALIR");
System.out.print("\n ESCOJA UNA OPCION : ");
op=Lee.datoInt();
switch (op)
{
case 1: obj.Suma(); break;
case 2: obj.Resta(); break;
case 3: obj.Multiplicacion(); break;
case 4: System.out.println("\nFin del programa."); break;
default: System.out.println("\n¡¡¡Error de seleccion!!!");
}
}while(op!=4);
}
}

class Leer //para operaciones de suma y resta y multiplicación de matrices del orden que se escoja.
{
public static String dato()
{
String sdato="";
try
{
InputStreamReader isr = new InputStreamReader (System.in);
BufferedReader flujo =new BufferedReader (isr);
sdato=flujo.readLine();
}
catch (IOException e)
{
System.err.println("Error"+ e.getMessage());
}
return sdato;
}
public static int datoInt()
{
try
{
return Integer.parseInt (dato());
}
catch(NumberFormatException e)
{
return Integer.MIN_VALUE;
}
}
public static float datoFloat()
{
try
{
Float f = new Float(dato());
return f.floatValue();
}
catch(NumberFormatException e)
{
return Float.NaN; // No es un Número; valor float.
}
}
}

class Operaciones // //para operaciones de suma y resta y multiplicación de matrices del orden que se escoja.

{
void Muestra(float M[][],int F,int C)
{
for(int y=0; y {
System.out.print("\n");
for(int x=0; x System.out.print(M[x][y]+" ");
}
}
void Muestra(int M[][],int F,int C)
{
for(int y=0; y {
System.out.print("\n");
for(int x=0; x System.out.print(M[x][y]+" ");
}
}

boolean Compara(int AX,int AY,int BX,int BY)
{
if ((AX==BX && AY==BY))
return true;
return false;
}

boolean Compara(int AX,int BY)
{
if ((AX==BY))
return true;
return false;
}

void Suma() // suma de matrices
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
System.out.println("\n Teclee el número de Filas y Columnas para las matrices.");
System.out.print("\n Filas de A:"); FA=Lee.datoInt();
System.out.print("\n Filas de B:"); FB=Lee.datoInt();
System.out.print("\n Columnas de A:"); CA=Lee.datoInt();
System.out.print("\n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FA,CB,FB))
{
System.out.println("\nElementeos para A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("\nElementeos para B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}

System.out.println("\nMatriz A:\n");
Obj.Muestra(A,FA,CA);
System.out.println("\nMatriz B:\n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x S[x][y]=A[x][y]+B[x][y];
System.out.println("\nLa suma es:\n");
Obj.Muestra(S,FA,CB);
}
else
{
System.out.println("\n Para sumarce las matrices tienen que tener las mismas dimenciones");
}
}

void Resta()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
System.out.println("\n Teclee el número de Filas y Columnas para las matrices.");
System.out.print("\n Filas de A:"); FA=Lee.datoInt();
System.out.print("\n Filas de B:"); FB=Lee.datoInt();
System.out.print("\n Columnas de A:"); CA=Lee.datoInt();
System.out.print("\n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FA,CB,FB))
{
System.out.println("\nElementeos para A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("\nElementeos para B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}

System.out.println("\nMatriz A:\n");
Obj.Muestra(A,FA,CA);
System.out.println("\nMatriz B:\n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x S[x][y]=A[x][y]+(B[x][y]*-1);
System.out.println("\nLa resta es:\n");
Obj.Muestra(S,FA,CB);
}
else
{
System.out.println("\n Para restarse las matrices tienen que tener las mismas dimenciones");
}
}

void Multiplicacion()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
int suma=0;
int h=0;
System.out.println("\n Teclee el número de Filas y Columnas para las matrices.");
System.out.print("\n Filas de A:"); FA=Lee.datoInt();
System.out.print("\n Filas de B:"); FB=Lee.datoInt();
System.out.print("\n Columnas de A:"); CA=Lee.datoInt();
System.out.print("\n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FB))
{
System.out.println("\nElementeos para A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("\nElementeos para B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}

System.out.println("\nMatriz A:\n");
Obj.Muestra(A,FA,CA);
System.out.println("\nMatriz B:\n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x {
h=0;
suma=0;
while(h {
suma+=A[h][y]*B[x][h];
h++;
}
S[x][y]=suma;
}
System.out.println("\nLa multiplicacion es:\n");
Obj.Muestra(S,FA,CB);
}
else
{
System.out.println("\n Para multiplicarse el numero de columnas de la matriz A tiene que ser igual \nal numero de filas de la matriz B");
}
}
}

PIB Ecuador

//PRONOSTICO DEL AÑO 2008
vector=[21250 24899 28636 32642 37187 41763 45789 48508]';
n=length(vector)
vector1=[0;vector(1:n-1)]
vector2=[0;0;vector(1:n-2)]
x=[vector1,vector2]
b=inv(x'*x)*(x'*vector)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
x=[vector1 vector2]
a=inv(x'*x)*(x'*vector)
z=a(1)*vector1+a(2)*vector2
plot(t,[vector z])
//error1=vector-z
//sqrt(error1'*error1)
//plot(error1)
t=[1:n+1]';
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
z=a(1)*vector1+a(2)*vector2
plot(t,z)


//PRONOSTICO DEL AÑO 98
vector=[18573 20195 21268 23635 23255]';
n=length(vector)
vector1=[0;vector(1:n-1)]
vector2=[0;0;vector(1:n-2)]
x=[vector1,vector2]
b=inv(x'*x)*(x'*vector)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
x=[vector1 vector2]
a=inv(x'*x)*(x'*vector)
z=a(1)*vector1+a(2)*vector2
plot(t,vector)
//error1=vector-z
//sqrt(error1'*error1)
//plot(error1)
t=[1:n+1]';
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
z=a(1)*vector1+a(2)*vector2
plot(t,z)

Pronostico del PIB

-Pronostico del 2008
zt=[21250 24899 28636 32642 37187 41763 45789 48508]';
n=length(zt)
zt1=[0;zt(1:n-1)]
zt2=[0;0;zt(1:n-2)]
x=[zt1,zt2]
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))
beta=imag(raiz(1))
r=sqrt(alfa^2+beta^2)
teta=acos(alfa/r)
t=[1:n]'
z1=(raiz(1).^t)
z2=(raiz(2).^t)
x=[z1 z2]
a=inv(x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2
plot(t,[zt z])
plot(t,zt)
e=zt-z
sqrt(e'*e)
plot(t,e)
t=[1:n+1]';
z1=(raiz(1).^t)
z2=(raiz(2).^t)
z=a(1)*z1+a(2)*z2
plot(t,z)


-Pronostico de PIB 1998
vector=[18573 20195 21268 23635 23255]';
n=length(V)
v1=[0;V(1:n-1)]
v2=[0;0;V(1:n-2)]
x=[v1,v2]b=inv(x'*x)*(x'*V)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)t=[1:n]'
v1=(raiz(1).^t)
v2=(raiz(2).^t)
x=[v1 v2]
a=inv(x'*x)*(x'* V)
z=a(1)*v1+a(2)*v2
plot(t, V)
e=V-z
sqrt(e'*e)
plot(e)
t=[1:n+1]';
v1=(raiz(1).^t)
v2=(raiz(2).^t)
z=a(1)*v1+a(2)*v2
plot(t,z)

Pronóstico del PIB en el Ecuador

//PRONOSTICO DEL AÑO 2008
vector=[21250 24899 28636 32642 37187 41763 45789 48508]';
n=length(vector)
vector1=[0;vector(1:n-1)]
vector2=[0;0;vector(1:n-2)]
x=[vector1,vector2]
b=inv(x'*x)*(x'*vector)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
x=[vector1 vector2]
a=inv(x'*x)*(x'*vector)
z=a(1)*vector1+a(2)*vector2
plot(t,[vector z])
//error1=vector-z
//sqrt(error1'*error1)
//plot(error1)
t=[1:n+1]';
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
z=a(1)*vector1+a(2)*vector2
plot(t,z)


//PRONOSTICO DEL AÑO 98
vector=[18573 20195 21268 23635 23255]';
n=length(vector)
vector1=[0;vector(1:n-1)]
vector2=[0;0;vector(1:n-2)]
x=[vector1,vector2]
b=inv(x'*x)*(x'*vector)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
x=[vector1 vector2]
a=inv(x'*x)*(x'*vector)
z=a(1)*vector1+a(2)*vector2
plot(t,vector)
//error1=vector-z
//sqrt(error1'*error1)
//plot(error1)
t=[1:n+1]';
vector1=(raiz(1).^t)
vector2=(raiz(2).^t)
z=a(1)*vector1+a(2)*vector2
plot(t,z)

Pronóstico del PIB

//******* 2000 AL 2007*********
///************************************************************
zt=[21250 24899 28636 32642 37187 41763 45789 48508]';
n=length(zt)
zt1=[0;zt(1:n-1)]
zt2=[0;0;zt(1:n-2)]
x=[zt1,zt2]
b=inv(x'*x)*(x'*zt)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
z1=(raiz(1).^t)
z2=(raiz(2).^t)
x=[z1 z2]
a=inv(x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2

plot(t,[zt z])


error1=zt-z
sqrt(error1'*error1)

t=[1:n+1]';
z1=(raiz(1).^t)
z2=(raiz(2).^t)
z=a(1)*z1+a(2)*z2
plot(t,z)


//******* 1993 AL 1997*************************************
//*********************************************************
zt=[18573 20195 21268 23635 23255]';
n=length(zt)
zt1=[10056;zt(1:n-1)]
zt2=[0;10056;zt(1:n-2)]
x=[zt1,zt2]
b=inv(x'*x)*(x'*zt)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
z1=(raiz(1).^t)
z2=(raiz(2).^t)
x=[z1 z2]
a=inv(x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2

//plot(t,[zt z])

plot(t,zt)
error1=zt-z
sqrt(error1'*error1)

t=[1:n+1]';
z1=(raiz(1).^t)
z2=(raiz(2).^t)
z=a(1)*z1+a(2)*z2
plot(t,z)

Clase Matriz

CLASE MATRIZ

class Matriz
{
private float[,] matriz;
private int filas, columnas;

public Matriz()
{

}

public Matriz(int f, int c)
{
filas = f;
columnas = c;
matriz = new float[filas, columnas];
}

//Método
public void leer()
{
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
Console.WriteLine("Ingrese el valor :[" + i + ", " + j + "]");
matriz[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}

public override string ToString()
{
return imprimir();
}

public static Matriz operator +(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] + m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}
// Método para multiplicar las matrices
public static Matriz operator *(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm2);
if (cm1 == fm2)
{
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
for (k = 0; k < cm1; k++)
{
aux.matriz[i, j] = aux.matriz[i, j] + (m1.matriz[i, k] * m2.matriz[k, j]);
}
}
}
}
return aux;
}

public static Matriz operator *(int n, Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;

int cont, cont1;
Matriz aux = new Matriz(fm1, cm1);

int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] * n;
}
}
return aux;
}
public static Matriz operator -(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] - m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}

public float determinante(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
float aux=1;
float aux1 = 1,aux2=1,det=0;

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
if (i == j)
{
aux = m1.matriz[i,j];
aux1 = aux * aux1;
}
else {
aux = m1.matriz[i,j];
aux2 = aux * aux2;
}
}
}
det = aux1 - aux2;
return det;
}

public Matriz Inversa(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(fm1, cm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] / determinante(m1);
}
}
return aux;
}

public Matriz Transpuesta(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(cm1, fm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[j, i] = m1.matriz[i, j];
}
}
return aux;
}

public string imprime()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
cad = "" + matriz[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}

Clase Matriz(C# con sobrecarga de operadores)

using System;
using System.Collections.Generic;
using System.Text;
namespace Operadores{

class Matriz {
private float[,] matriz;
private int filas, columnas;

public Matriz() {
}

public Matriz(int fila, int columna) {
filas = fila;
columnas = columna;
matriz = new float[filas, columnas];
}

public void leer()
{
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
Console.WriteLine("Ingrese el valor en la posicion [" + i + ", " + j + "]");
matriz[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}

public override string ToString()
{
return imprime_matriz();
}

public static Matriz operator +(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] + m2.matriz[i - 1, j- 1];
}
}
}
return aux;
}

public static Matriz operator *(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm2);
if (cm1 == fm2)
{
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
for (k = 0; k < cm1; k++)
{
aux.matriz[i, j] = aux.matriz[i, j] + (m1.matriz[i, k] * m2.matriz[k, j]);
}
}
}
}
return aux;
}

public static Matriz operator *(int n, Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm1);
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] * n;
}
}
return aux;
}

public static Matriz operator -(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] - m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}

public float determinante(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
float aux=1;
float aux1 = 1,aux2=1,det=0;
for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
if (i == j)
{
aux = m1.matriz[i,j];
aux1 = aux * aux1;
}
else {
aux = m1.matriz[i,j];
aux2 = aux * aux2;
}
}
}
det = aux1 - aux2;
return det;
}

public Matriz Inversa(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(fm1, cm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] / determinante(m1);
}
}
return aux;
}

public Matriz Transpuesta(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(cm1, fm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[j, i] = m1.matriz[i, j];
}
}
return aux;
}

public string imprime_matriz()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
cad = "" + matriz[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}

Clase Matriz (C#)

using System;
using System.Collections.Generic;
using System.Text;
namespace Matriz
{
public class clsMatriz
{
public float[,] mat = new float[10, 10];
public int limf, limc;
public float deter;

public clsMatriz()
{
for (int i = 0; i < j =" 0;" deter =" 0;">
public void leer()
{
do
{
Console .WriteLine ("De cuantas filas desea la matriz? ingrese un valor max de 10\t");
limf = Convert.ToInt32(Console.ReadLine());
} while (limf <= 0 limf > 10);
do
{
Console.WriteLine("De cuantas columnas desea la matriz? ingrese un valor max de 10\t");
limc = Convert.ToInt32(Console.ReadLine());
} while (limc <= 0 limc > 10);

for (int i = 0; i < limf; i++)
for (int j = 0; j < limc; j++)
{
Console.WriteLine("Ingrese el elemento de la fila"+(i + 1)+"de la columna"+(j + 1) +"\t");
mat[i,j]=Convert .ToInt32(Console.ReadLine());
}
}

public void Escribe()
{
string aux="";
for (int i = 0; i < this.limf; i++)
{
for (int j = 0; j < this.limc; j++)
aux = aux + this.mat[i, j] + "\t";
aux = aux + "\n";
}
Console.Write(aux);
}


public static clsMatriz operator +(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m1.limf; i++)
for (int j = 0; j < m1.limc; j++)
m3.mat[i,j] = m1.mat[i, j] + m2.mat [i, j];
return m3;
}


public static clsMatriz operator -(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m1.limf; i++)
for (int j = 0; j < m1.limc; j++)
m3.mat[i, j] = m1.mat[i, j] - m2.mat[i, j];
return m3;
}


public static clsMatriz operator *(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m3.limf; i++)
{
for (int j = 0; j < m3.limc; j++)
{
m3.mat[i,j] = 0;
for (int l = 0; l < m1.limc; l++)
{
m3.mat[i,j] = m3.mat[i,j] + (m1.mat[i,l] * m2.mat[l,j]);
}
}
}
return m3;
}


public bool ValidaMatCuadrada(clsMatriz m1, clsMatriz m2)
{
bool valida=false;
if (m1.limf == m2.limf && m1.limc == m2.limc)
valida=true;
return valida;
}

public bool ValidaMultiplicacion(clsMatriz m1, clsMatriz m2)
{
bool valida=false;
if (m1.limc == m2.limf)
valida=true;
return valida;
}

public void Deter()
{
deter = this.mat[0, 0] * this.mat[1, 1] - this.mat[0, 1] * this.mat[1, 0];
}


public void Inversa()
{
this.Deter();
if (this.deter != 0)
{
float aux;
aux = this.mat[0, 0] / this.deter;
this.mat[0, 0] = this.mat[1, 1] / this.deter;
this.mat[1, 1] = aux;
this.mat[1, 0] = (this.mat[1, 0] * (-1))/this.deter ;
this.mat[0, 1] = (this.mat[0, 1] * (-1))/ this.deter ;
}
}


public clsMatriz Transpuesta()
{
clsMatriz m3 = new clsMatriz();
m3.limf = this.limf;
m3.limc = this.limc;
for (int i = 0; i < this.limf; i++)
{
for (int j = 0; j < this.limc; j++)
m3.mat [j,i]=this.mat [i,j];
}
return m3;
}

}
}

Clase Matriz

using System;
using System.Collections.Generic;
using System.Text;
namespace Matrices
{
public class clsMatriz
{
private double[,] mat;
private int fila, colum;
public clsMatriz()
{
}
public clsMatriz(int f, int c)
{
fila = f;
colum = c;
mat = new double[fila, colum];
}
public void leerMatriz()
{
for (int i = 1; i <= fila; i++)
{
for (int j = 1; j <= colum; j++)
{
Console.WriteLine("Ingrese el valor en la posicion [" + i + ", " + j + "]");
mat[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}
public override string ToString()
{
return Matriz();
}
public static clsMatriz operator +(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2= mat2.fila;
int cmat2 = mat2.colum;
clsMatriz suma = new clsMatriz(fmat1, cmat2);
if ((fmat1 == fmat2) && (cmat1 == cmat2))
{
for (int i = 1; i <= suma.fila; i++)
{
for (int j = 1; j <= suma.colum; j++)
{
suma.mat[i - 1, j - 1] = mat1.mat[i - 1, j - 1] + mat2.mat[i - 1, j - 1];
}
}
}
return suma;
}
public static clsMatriz operator -(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2 = mat2.fila;
int cmat2 = mat2.colum;
clsMatriz resta = new clsMatriz(fmat1, cmat1);
if ((fmat1 == fmat2) && (cmat1 == cmat2))
{
for (int i = 1; i <= resta.fila; i++)
{
for (int j = 1; j <= resta.colum; j++)
{
resta.mat[i - 1, j - 1] = mat1.mat[i - 1, j - 1] - mat2.mat[i - 1, j - 1];
}
}
}
return resta;
}
public static clsMatriz operator *(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2 = mat2.fila;
int cmat2 = mat2.colum;
int aux;
clsMatriz multiplicacion = new clsMatriz(fmat1, cmat2);
if (cmat1 == fmat2)
{
for (int i = 0; i < multiplicacion.fila; i++)
{
aux = 0;
for (int j = 0; j < multiplicacion.colum; j++)
{
for (int k = 0; k < cmat1; k++)
{
multiplicacion.mat[i, j] = multiplicacion.mat[i, j] + (mat1.mat[i, k] * mat2.mat[k, j]);
}
}
}
}
return multiplicacion;
}
public static clsMatriz operator *(int num, clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int aux;
clsMatriz escalar = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < escalar.fila; i++)
{
aux = 0;
for (int j = 0; j < escalar.colum; j++)
{
escalar.mat[i, j] = mat1.mat[i, j] * num;
}
}
return escalar;
}
public double CalculaDeterminante(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
double temp = 1, temp1 = 1, temp2 = 1, det = 0;
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
if (i == j)
{
temp = mat1.mat[i, j];
temp1 = temp * temp1;
}
else
{
temp = mat1.mat[i, j];
temp2 = temp * temp2;
}
}
}
det = temp1 - temp2;
return det;
}
public clsMatriz MatrizInversa(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
clsMatriz inversa = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
try
{
inversa.mat[i, j] = mat1.mat[i, j] / CalculaDeterminante(mat1);
}
catch (DivideByZeroException)
{
Console.WriteLine("No se puede realizar la division por 0");
}
}
}
return inversa;
}
public clsMatriz MatrizTranspuesta(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
clsMatriz transpuesta = new clsMatriz(cmat1, fmat1);
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
transpuesta.mat[j, i] = mat1.mat[i, j];
}
}
return transpuesta;
}
public clsMatriz MatrizIdentidad(clsMatriz mat1)
{
clsMatriz inv=new clsMatriz();
inv = MatrizInversa(mat1);
int fmatinv = inv.fila;
int cmatinv = inv.colum;
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int aux;
clsMatriz identidad = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < identidad.fila; i++)
{
for (int j = 0; j < identidad.colum; j++)
{
for (int k = 0; k < cmatinv; k++)
{
identidad.mat[i, j] = identidad.mat[i, j] + (mat1.mat[i, k] * inv.mat[k, j]);
}
}
}
return identidad;
}
public string Matriz()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= fila; i++)
{
for (int j = 1; j <= colum; j++)
{
cad = "" + mat[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}