PROGRAM MENU /* NOMBRE DEL PROGRAMA

IMPLICIT NONE
INTEGER::I,J,FA,CA,FB,CB,R1,R2,OP /*VARIABLES ENTERAS (INTEGER) A USAR DURANTE TODO
EL PROGRAMA
INTEGER::K=1
REAL(KIND=2),ALLOCATABLE,DIMENSION(:,:)::A,B,C /*SE DECLARAN A LAS MATRICES CON
DIMENSION VARIABLE
REAL(KIND=2),ALLOCATABLE,DIMENSION(:)::V1,V2 /*SE DECLARAN LOS VECTORES CON
DIMENSION VARIABLE
REAL::ESC,V3

R1=1

DO WHILE(R1==1) /*SE ENTRA POR AUTOMATICO AL CICLO HACER-MIENTRAS

WRITE(*,*)"*******************************************************"
WRITE(*,*)"* PROGRAMA ELABORADO POR BRYAN DAVID SIERRA MURILLO *" /*MENU DE
OPCIONES
WRITE(*,*)"*******************************************************" /*SE
MUESTRAN EN PANTALLA
WRITE(*,*)
WRITE(*,*) "ESTE PROGRAMA TE PERMITE HACER DISTINTAS OPERACIOENS ENTRE
MATRICES."
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"SELECCIONA UNA OPCION"
WRITE(*,*)"1) SUMA DE MATRICES"
WRITE(*,*)"2) MULTIPLACION DE UNA MATRIZ POR UN ESCALAR"
WRITE(*,*)"3) MULTIPLICACION DE 2 MATRICES"
WRITE(*,*)"4) PRODUCTO PUNTO DE DOS VECTORES"
WRITE(*,*)"5) PRODUCTO CRUZ DE DOS VECTORES"
WRITE(*,*)"6) TRANSPUESTA DE UNA MATRIZ"
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"RESPUESTA"
READ(*,*)OP /*GUARDA EL VALOR EN LA VARIABLE ENTERA
WRITE(*,*)"---------------------------------------------------"
SELECT CASE(OP) /*DEPENDIENDO DEL VALOR GUARDADO SE HARAN LOS SIGUIENTES CASOS
CALL SYSTEM('CLS') /* LIMPIA PANTALLA

CASE(1) /*SE REALIZA EL CASO 1

/*PREGUNTA AL USUARIO EL TAMA�O DE SUS MATRICES Y ALMACENA EL VALOR EN SUS

VARIABLES
WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ A"
READ(*,*)FA
WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ A"
READ(*,*)CA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ B"
READ(*,*)FB
WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ B"
READ(*,*)CB
CALL SYSTEM('CLS')
IF(FA==FB.AND.CA==CB)THEN /*ESTRUCTURA DE DESICION SI CUMPLE SE PROCEDE A
REALIZAR SI NO CUMPLE DICHA CONDICION MANDA UN MENSAJE DE DEFECTO
ALLOCATE(A(FA,CA)) /*INDICA AL PROGRAMA LA DIMENSION QUE TENDRAN LAS MATRICES
ALLOCATE(B(FB,CB))
ALLOCATE(C(FA,CA))
WRITE(*,*)"**********************"
WRITE(*,*)"* SUMA DE MATRICES *"
 WRITE(*,*)"**********************"
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"MATRIZ A"

DO I=1,FA /*SE EMPIEZA A GUARDAR LOS ELEMENTOS EN LA MATRIZ A

DO J=1,CA
WRITE(*,*)"DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)A(I,J)
END DO
END DO

WRITE(*,*)"---------------------------------------------------" /*SEPARA EL TEXTO

WRITE(*,*)"MATRIZ B"

DO I=1,FB /*GUARDA LOS ELEMTOS EN LA MATRIZ B

DO J=1,CB
WRITE(*,*)"DE TU MATRIZ B DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)B(I,J)
END DO
END DO

/*REALIZAR LA OPERACION DE SUMA DE MATRICES

DO I=1,FA
DO J=1,CA
C(I,J)=A(I,J)+B(I,J)
END DO
END DO

WRITE(*,*)"---------------------------------------------------"

WRITE(*,*)"TU NUEVA MATRIZ ES" /*IMPRIME LA NUEVA MATRIZ

DO I=1,FA
WRITE(*,*)C(I,1:CA)

END DO
ELSE
WRITE(*,*)"TU MATRIZ A DEBE SER DE NXM Y B DE NXM"
END IF /*TERMINA IF

WRITE(*,*)"---------------------------------------------------"

/*MANDA AL USUARIO EL MENSAJE DE PODER REPETIR EL PROGRAMA

WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"
WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
DEALLOCATE(A)/* BORRA TODO VALOR ALMACENADO DESPUES DE SU EJECUCION PARA
PODER VOLVER A USARSE
DEALLOCATE(B)
DEALLOCATE(C)
CALL SYSTEM('CLS')

CASE(2) /*SE EJECUTA EL CASO 2

/*PREGUNTA LAS DIMENSIONES DE LA MATRIZ

WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ A"

 READ(*,*)FA
WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ A"
READ(*,*)CA
CALL SYSTEM('CLS')

ALLOCATE(A(FA,CA)) /*ALOJA LAS DIMENSIONES DE LA MATRIZ

ALLOCATE(C(FA,CA))
WRITE(*,*)"*************************************************"
WRITE(*,*)"* MULTIPLICACION DE UNA MATRIZ POR UN ESCALAR *"
WRITE(*,*)"*************************************************"
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"MATRIZ A"

/*PIDE Y ALMACENA LOS VALORES DE LA MATRIZ A

DO I=1,FA
DO J=1,CA
WRITE(*,*)"DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)A(I,J)
END DO
END DO

WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"DAME EL VALOR DE TU ESCALAR"
READ(*,*)ESC /*SOLICITA EL ESCALAR AL USUARIO

/*REALIZA LA OPERACION DE MULTIPLICACION DE LA MATRIZ POR EL ESCALAR

DO I=1,FA
DO J=1,CA
C(I,J)=ESC*A(I,J)
END DO
END DO
/*MUESTRA EN PANTALLA LA NUEVA MATRIZ
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU NUEVA MATRIZ ES"
DO I=1,FA
WRITE(*,*)C(I,1:CA)

END DO

WRITE(*,*)"---------------------------------------------------"

WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"

WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
DEALLOCATE(A)/*BORRA LOS VLAORES GUARDADOS EN LA MATRIZ A
DEALLOCATE(C)
CALL SYSTEM('CLS')

CASE(3) /*REALIZA EL CASO 3

/*PIDE LAS DIMENSIONES DE LA MATRIZ
WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ A"
READ(*,*)FA
WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ A"
READ(*,*)CA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ B"
READ(*,*)FB
 WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ B"
READ(*,*)CB

CALL SYSTEM('CLS') /*LIMPIA PANTALLA

IF(CA==FB) THEN /*ESTRUCTURA DE DESICION SI CUMPLE SE REALIZA
ALLOCATE(A(FA,CA)) /*ALMACENA LAS DIENSIONES DE LA MATRIZ
ALLOCATE(B(FB,CB))
ALLOCATE(C(FA,CA))
WRITE(*,*)"***********************************"
WRITE(*,*)"* MULTIPLICACION ENTRE MATRICES *"
WRITE(*,*)"***********************************"
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"MATRIZ A"
/*PIDE Y ALMACENA LOS VALROES DE LA MATRIZ A
DO I=1,FA
DO J=1,CA
WRITE(*,*)"DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)A(I,J)
END DO
END DO

WRITE(*,*)"---------------------------------------------------"
/*PIDE Y ALMACENA LOS VALORES DE LA MATRIZ B
WRITE(*,*)"MATRIZ B"
DO I=1,FB
DO J=1,CB
WRITE(*,*)"DE TU MATRIZ B DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)B(I,J)
END DO
END DO
/*REALIZA LA OPERACION DE MULTIPLICACION DE AMBAS MATRICES
DO I=1,FA
DO J=1,CA
C(I,J)=0
DO K=1,FA
C(I,J)=C(I,J)+A(I,K)*B(K,J)
END DO
END DO
END DO
/*IMPRIME LA NUEVA MATRIZ
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU NUEVA MATRIZ ES"
DO I=1,FA
WRITE(*,*)C(I,1:CA)

END DO
ELSE /*EN CASO DE QUE NO SE CUMPLA LA ESTRUCTURA DE DESICION MANDA MENSAJE AL
USUARIO
WRITE(*,*)"TU MATRIZ A DEBE SER DE NXM Y B DE NXM"
END IF

WRITE(*,*)"---------------------------------------------------"

WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"

WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
DEALLOCATE(A) /*BORRA TODO DATO ALMACENADO EN LA MATRIZ
 DEALLOCATE(B)
DEALLOCATE(C)
CALL SYSTEM('CLS')

CASE(4) /*REALIZA EL CASO 4

/*PIDE LOS ELEMENTOS DEL VECTOR

WRITE(*,*)"CUANTOS ELEMENTOS TIENES TU VECTOR 1"
READ(*,*)FA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"CUANTOS ELEMENTOS TIENE TU VECTOR 2"
READ(*,*)FB
WRITE(*,*)"---------------------------------------------------"
CALL SYSTEM('CLS')

ALLOCATE (V1(FA))/*ALOJA LAS DIMENSIONES DEL VECTOR

ALLOCATE (V2(FB))

IF (FA==FB) THEN /*ESTRUCTURA DE SELECCION SI CUMPLE LA CONDICION SE REALIZA

EL DICHAS INSTRUCCIONES
/*REALIZA LAS OPERACIONES CORRESPONDIENTES
V3=0

WRITE(*,*)"************************************"
WRITE(*,*)"* PRODUCTO PUNTO DE DOS VECTORES *"
WRITE(*,*)"************************************"
/*PIDE Y GUARDA LOS VALORES DEL VECTOR 1
DO I=1,FA
WRITE(*,*)
WRITE(*,*)"DE TU PRIMER VECTOR DAME EL",I
READ(*,*)V1(I)
END DO
WRITE(*,*)"---------------------------------------------------"
/*PIDE Y GUARDA LOS VALORES DEL VECTOR 2
DO I=1,FB
WRITE(*,*)
WRITE(*,*)"DE TU SEGUNDO VECTOR DAME EL",I
READ(*,*)V2(I)
END DO
WRITE(*,*)"---------------------------------------------------"

DO I=1,FA
V3=V3+V1(I)*V2(I)
END DO
WRITE(*,*)"---------------------------------------------------"
/*IMPRIME EL RESULTADO
WRITE(*,*)"EL ESCALAR ES",V3

ELSE /*EN CASO DE QUE LA CONDICION NO SE CUMPLA SE IMPRIME EL MENSAJE EN LA

PANTALLA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU PRIMER VECTOR TIENE QUE TENER EL MISMO NUMERO DE ELEMENTOS
QUE TU SEGUNDO"
WRITE(*,*)"VECTOR"

END IF /*TERMINA LA ESTRUCTURA IF

WRITE(*,*)"---------------------------------------------------"
 WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"
WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1

DEALLOCATE (V1)/*BORRA LOS VALORES GUARDADOS EN LOS VECTORES

DEALLOCATE (V2)
CALL SYSTEM('CLS')

CASE(5) /*SE REALIZA EL CASO 5

FA=1 /*SE ASIGNA EL VALOR DE LAS FILAS(F) Y COLUMNAS (C)DE LA MATRIZ A Y B

FB=1
CA=3
CB=3
CALL SYSTEM('CLS')

WRITE(*,*)"-----------------------------------------------------------------"
WRITE(*,*)"-- POR SENCILLEZ SOLO SE PERMITIRAN 3 ELEMENTOS DE CADA VECTOR --"
WRITE(*,*)"-----------------------------------------------------------------"
WRITE(*,*)

WRITE(*,*)"******************************************************"
WRITE(*,*)"* PRODUCTO CRUZ DE DOS VECTORES (CON 3 ELEMENTOS) *"
WRITE(*,*)"******************************************************"

IF (CA==CB) THEN /*ESTRUCTURA DE SELECCION SI CUMPLE LA CONDICION REALIZA LAS

INSTRUCCIONES

ALLOCATE(A(FA,CA)) /*ALOJA LAS DIMENSIONES DE LA MATRIZ

ALLOCATE(B(FB,CB))
ALLOCATE(C(FA,CA))
/*SOLICITA Y GUARDA LOS VALORES DE LA MATRIZ A
DO I=1,FA
DO J=1,CA
WRITE(*,*)
WRITE(*,*)"DE TU PRIMER VECTOR DAME EL",J
READ(*,*)A(I,J)
END DO
END DO
WRITE(*,*)"---------------------------------------------------"
/*SOLICITA Y GUARDA LOS VALORES DE LA MATRIZ B
DO I=1,FB
DO J=1,CB
WRITE(*,*)
WRITE(*,*)"DE TU SEGUNDO VECTOR DAME EL",J
READ(*,*)B(I,J)
END DO
END DO
/*REALIZA LAS OPERACIONES CORRESPONDIENTES
C(1,1)=(A(1,2)*B(1,3))-(A(1,3)*B(1,2))
C(1,2)=(A(1,1)*B(1,3))-(A(1,3)*B(1,1))
C(1,3)=(A(1,1)*B(1,2))-(A(1,2)*B(1,1))
/*IMPRIME EL RESULTADO
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU VECTOR ES"
 DO I=1,1
WRITE(*,*)C(I,1:3)
END DO
ELSE /*EN CASO DE QUE NO SE CUMPLA LA CONDICION SE MANDA EL MENSAJE A
PANTALLA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU PRIMER VECTOR TIENE QUE TENER EL MISMO NUMERO DE ELEMENTOS
QUE TU SEGUNDO VECTOR"
END IF
WRITE(*,*)"---------------------------------------------------"

WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"

WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
DEALLOCATE(A)/*BORRA LOS ELEMENTOS GUARDADOS
DEALLOCATE(B)
DEALLOCATE(C)
CALL SYSTEM('CLS')

CASE(6)/*SE REALIZA EL CASO 6

/*PIDE LAS DIMENSIONES DE LA MATRIZ A

WRITE(*,*)"CUANTAS FILAS TIENE TU MATRIZ A"
READ(*,*)FA
WRITE(*,*)"CUANTAS COLUMNAS TIENE TU MATRIZ A"
READ(*,*)CA
WRITE(*,*)"---------------------------------------------------"
CALL SYSTEM('CLS')/* LIMPIA PANTALLA
WRITE(*,*)"*******************************"
WRITE(*,*)"* TRANSPUESTA DE UNA MATRIZ *"
WRITE(*,*)"*******************************"
K=1
IF(K==1) THEN/*ENTRA AL CICLO POR DEFECTO
ALLOCATE (A(FA,CA))/*ALMACENA LAS DIMENSIONES DE LA MATRIZ
ALLOCATE (B(CA,FA))
/*PIDE Y GUARDA LOS VALORES DE LA MATRIZ A
DO I=1,FA
DO J=1,CA
WRITE(*,*)"DAME EL VALOR DE ","(",I,",",J,")"
READ(*,*)A(I,J)
END DO
END DO
/*REALIZA LA OPERACION PARA TRASPONER LA MATRIZ
DO I=1,CA
DO J=1,FA
B(I,J)=A(J,I)
END DO
END DO
/*IMPRIME LA MATRIZ TRANSPUESTA
WRITE(*,*)"---------------------------------------------------"
WRITE(*,*)"TU MATRIZ TRANSPUESTA ES"
WRITE(*,*)
DO I=1,CA
WRITE(*,*)B(I,1:FA)
END DO

WRITE(*,*)"DESEAS REGRESAR AL MENU PRINCIPAL"

 WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
DEALLOCATE (A)
DEALLOCATE (B)
CALL SYSTEM('CLS')
END IF /*TERMINA LA ESTRUCTURA SELECTIVA DE DESICION

CASE DEFAULT/* SI EL VALOR INGRESADO ES INCORRECTO EN EL MENU SE MANDA MENSAJE EN

PANTALLA
WRITE(*,*)"DIGITO INCORRECTO"
WRITE(*,*)"DESEAS REPETIR EL PROGRAMA"
WRITE(*,*)"SI DIGITA 1"
WRITE(*,*)"NO DIGITA 2"
WRITE(*,*) "RESPUESTA"
READ(*,*)R1
CALL SYSTEM('CLS')
END SELECT /*TERMINA LA ESTRUCTURA DE CONTROL

END DO/*TERMINA EL CICLO DO

END PROGRAM /*TERMINA EL PROGRAMA