CODIGO:

1
2
3
4
5
6
7
8

package javaapplication23;
import java.util.*;
import java.lang.*;
public class Determinante {
double [][]cargar (double A[][])
{
int n = A.length;
Scanner entrada = new Scanner(System.in);
System.out.println("ingrese el orden de la matriz
9 cuadrada:");
10
n=entrada.nextInt();
11
12
for(int i=0; i<n;i++)
13
{
14
for(int j=0; j<n;j++)
15
{
System.out.println("ingrese elemnto A["+(i+1)+"]["+
16 (j+1)+"]:");
17
A[i][j]= entrada.nextDouble();
18
}
19
}
20
return A;
21 }
22
23
private double [][]Submatriz(int i,int j,double a[][])
24
{
25
double b[][] = new double [a.length-1][a.length-1];
26
27
int contador1=0;
28
int contador2=0;
29
30
for (int k=0 ; k<a.length;k++)
31
{
32
if(k!=i)
33
{
34
contador2=0;
35
for (int p=0 ; p<a.length;p++)
36
{
37
if(p!=j)
38
{
39
b[contador1][contador2]= a[k][p];
40

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

contador2++;
}
}
contador1++;
}
}
return b;
}
double determinante (int i,double a[][])
{
if (a.length==2)
{
double det= a[0][0]*a[1][1]-a[0][1]*a[1][0];
return det;
}
else
{
double det=0;
for (int j=0 ; j<a.length;j++)
{
double b[][]= this.Submatriz(i,j,a);
det=det+Math.pow(-1,i+j)*a[i]
[j]*determinante(i,b);
}
return det;
}
}
public static void main(String[] args) {
double a[][]={{4,0,0},{0,5,0},{0,0,1}};
Determinante obj1 = new Determinante();

76 System.out.println("determinante:"+obj1.determinante(0,a));
77
}
78
79 }

determinante:2
0.0

Matriz Inversa
1
2
3
4
5

package javaapplication22;
import java.util.*;
import javax.swing.JOptionPane;
public class MatrizInversa {
public static double [][] matrizInversa(double[][]matriz)

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

{ double det=1/determinante(matriz);
double[][]nmatriz=matrizAdjunta(matriz);
multiplicarMatriz(det,nmatriz);
return nmatriz;
}
public static void multiplicarMatriz(double n,double[][]
matriz)
{
for(int i=0;i<matriz.length;i++)
for(int j=0;j<matriz.length;j++)
matriz[i][j]*=n;
}
public static double[][] matrizAdjunta(double[][] matriz)
{
return matrizTranspuesta(matrizCofactores(matriz));
}
public static double[][] matrizCofactores(double[]
[]matriz)
{
double[][] nm=new double[matriz.length]
[matriz.length];
for(int i=0;i<matriz.length;i++){
for(int j=0;j<matriz.length;j++){

double[][]det=new double[matriz.length-1]
27 [matriz.length-1];
28
double detValor;
29
for (int k=0;k<matriz.length;k++){
30
if(k!=i){
31
for(int l=0;l<matriz.length;l++)
32
{if(l!=j){
33
int indice1=k<i?k:k-1;
34
int indice2=l<j?l:l-1;
35
det[indice1][indice2]=matriz[k][l];
36
}
37
}
38
}
39
}
40
detValor=determinante(det);
41
nm[i][j]=detValor*(double)Math.pow(-1,i+j+2);
42
}
43
}
44
return nm;
45
}

public static double[][] matrizTranspuesta(double []

46 []matriz)
47
{
double[][]nuevam=new double[matriz[0].length]
48 [matriz.length];
49
for(int i=0;i<matriz.length;i++)
50
{
51
for(int j=0;j<matriz.length;j++)
52
{ nuevam[j][i]=matriz[i][j];
53
}
54
}
55
return nuevam;
56
}
57
public static double determinante(double[][] matriz)
58
{ double det;
59
if(matriz.length==2)
60
{
det=(matriz[0][0]*matriz[1][1])-(matriz[1][0]*matriz[0]
61 [1]);
62
return det;
63
}
64
double suma=0;
65
for(int i=0;i<matriz.length;i++)
66
{
double[][] nm=new double[matriz.length-1]
67 [matriz.length-1];
68
for(int j=0;j<matriz.length;j++){
69
if(j!=i){
70
for(int k=1;k<matriz.length;k++){
71
int indice;
72
if(j<i)
73
indice=j;
74
else
75
indice=j-1;
76
nm[indice][k-1]=matriz[j][k];
77
}
78 }
79 }
80 if(i%2==0)
81
suma+=matriz[i][0]*determinante(nm);
82 else
83
suma-=matriz[i][0]*determinante(nm);
84 }
85 return suma;

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

}
public static void imprimir(double[][]mat)
{
for(int i=0;i<mat.length;i++)
{
for(int j=0;j<mat[0].length;j++)
{
System.out.print(mat[i][j]+"; ");
}
System.out.println();
}
}
public static void main(String[] args) {
double[][] deltaS={{1,2,4},
{3,3,4},
{2,3,1}};

104 System.out.println("Determinante:"+determinante(deltaS));
105
MatrizInversa obj1=new MatrizInversa();
106
System.out.println("Matriz Transpuesta");
107
obj1.imprimir(matrizTranspuesta(deltaS));
108
System.out.println("Matriz cofactores");
109
obj1.imprimir(matrizCofactores(deltaS));
110
System.out.println("Matriz Adjunta");
111
obj1.imprimir(matrizAdjunta(deltaS));
112
System.out.println("Mtariz invresa");
113
obj1.imprimir(matrizInversa(deltaS));
114 }
115 }
|

Determinante:13.0

Matriz Transpuesta
1.0; 3.0; 2.0;
2.0; 3.0; 3.0;
4.0; 4.0; 1.0;
Matriz cofactores
-9.0; 5.0; 3.0;
10.0; -7.0; 1.0;
-4.0; 8.0; -3.0;
Matriz Adjunta
-9.0; 10.0; -4.0;
5.0; -7.0; 8.0;
3.0; 1.0; -3.0;
Mtariz invresa
-0.6923076923076923; 0.7692307692307693;
-0.3076923076923077;
0.38461538461538464; -0.5384615384615385;
0.6153846153846154;
0.23076923076923078; 0.07692307692307693;
-0.23076923076923078;

DIAGRAMA DE FLUJO:

Producto de
matrices
CODIGO:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package javaapplication21;
public class Producto
{
double [][]producto(double[][]A,double [][]B)
{
double c[][]=new double [A.length][B[0].length];
for (int i = 0; i < A.length; i++)
{
for (int j = 0; j < B[0].length; j++)
{
for (int k = 0; k < A[0].length; k++)
{
c[i][j] += A[i][k]*B[k][j];
}
}
}
return c;
}
void imprimir(double x[][])
{
for (int i = 0; i < x.length; i++)
{
for (int j = 0; j < x[0].length; j++)

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 }

{
System.out.print(" "+x[i][j]);
}
System.out.println();
}
}
public static void main(String[] args)
{
double A[][]={{3,4,2},{5,7,1},{3,2,3}};
double B[][]={{1,2,3},{4,5,6},{7,8,9}};
Producto obj = new Producto();
obj.imprimir(obj.producto(A, B));
}

33.0 42.0 51.0

40.0 53.0 66.0
32.0 40.0 48.0

DIAGRAMA DE FLUJOS: