AO3 Ej2 Campetella

Actividad Obligatoria 3
Conrado Campetella
Ejercicio 1
Obtenga los intercambios de renglones que se requieren para resolver los
siguientes sistemas de ecuaciones lineales aplicando algoritmos, los cuales
pueden ser utilizados en programas de computadoras.
Utilizando los siguientes algoritmos:
a)
b)
c)
d)
Eliminacin
Eliminacin
Eliminacin
Eliminacin
Gaussiana
Gaussiana
Gaussiana
Gaussiana
con
con
con
con
sustitucin hacia atrs.

pivoteo parcial.
pivoteo parcial escalonado.
pivoteo completo.
2)
2x 13x 2+ 2x 3=5
4x 1+ 2x 26x 3=14
2x 1 +2x 24x 3=8
Para resolver el problema se realiz un programa en java. El cdigo del
mismo se encuentra en el Anexo de la actividad.
El programa solicita ingresar el sistema y luego arroja la siguiente solucin.
La misma incluye la solucin del sistema utilizando la regla de Cramer.
Respecto a la misma, el programa solo funciona para sistemas de 3
ecuaciones con 3 incgnitas ya que solo puede calcular determinante de
matrices de 3x3.
Corremos el programa e ingresamos este sistema para obtener su solucin
por los distintos mtodos. El resultado obtenido es:
Programa para resolver sistemas de igual cantidad de incgnitas que
ecuaciones
Ingrese la cantidad de incgnitas y ecuaciones que tiene el sistema
3
Para ecuaciones de la forma a1X1+a2X2+..+anXn=bn
Ingrese a0 de la ecuacin 0
2
-3
2
Ingrese b0 de la ecuacin 0
5
-4
2
-6
14
2
2
-4
8
El sistema ingresado es:
2.0X0 -3.0X1 2.0X2 = 5.0
-4.0X0 2.0X1 -6.0X2 = 14.0
2.0X0 2.0X1 -4.0X2 = 8.0
La matriz ampliada del sistema es:
| 2.0 -3.0
| -4.0 2.0 -6.0
| 2.0 2.0
-4.0
2.0
5.0 |
14.0
8.0 |
La matriz ampliada luego de aplicar Gauss es:

| 2.0 -3.0
| 0.0 -4.0
| 0.0 0.0
2.0
-2.0
-8.5
5.0 |
33.0
24.0
|
Su solucin es:
X0 = 0.2941176470588238 X1 = -4.0588235294117645
-3.8823529411764706
-----------------------------------------------Utilizando Gauss con Pivoteo parcial
2.0X0 -3.0X1 2.0X2 = 5.0
-4.0X0 2.0X1 -6.0X2 = 14.0
2.0X0 2.0X1 -4.0X2 = 8.0
| 2.0 -3.0
| -4.0 2.0 -6.0
| 2.0 2.0
-4.0
2.0
5.0 |
14.0
8.0 |
X2 =
La matriz ampliada del sistema luego del pivoteo parcial es:

| -4.0 2.0 -6.0
| 2.0 -3.0
| 2.0 2.0
-4.0
2.0
14.0
5.0 |
8.0 |

| -4.0 2.0 -6.0
| 0.0 -2.0
| 0.0 0.0
-8.5
14.0 |
-1.0 12.0
33.0 |
Su solucin es:
X0 = 0.2941176470588234 X1 = -4.0588235294117645
-3.8823529411764706
-----------------------------------------------Utilizando Gauss con Pivoteo parcial Escalonado
2.0X0 -3.0X1 2.0X2 = 5.0
-4.0X0 2.0X1 -6.0X2 = 14.0
2.0X0 2.0X1 -4.0X2 = 8.0
X2 =

| 2.0 -3.0
| -4.0 2.0 -6.0
| 2.0 2.0
-4.0
2.0
5.0 |
14.0
8.0 |
La matriz ampliada del sistema luego del pivoteo 1 parcial es:

| -4.0 2.0 -6.0
| 2.0 -3.0
| 2.0 2.0
-4.0
2.0
14.0
5.0 |
8.0 |
La matriz ampliada del sistema luego del pivoteo 2 parcial es:

| -4.0 2.0 -6.0
| 0.0 3.0 -7.0
| 0.0 -2.0
14.0 |
15.0 |
-1.0 12.0

| -4.0 2.0 -6.0 14.0 |
| 0.0 3.0
-7.0 15.0 |
| 0.0 0.0
-5.66 22.0 |
Su solucin es:
X0 = 0.29411764705882426 X1 = -4.058823529411765 X2 =
-3.882352941176471
-----------------------------------------------Utilizando Gauss con Pivoteo Completo
2.0X0 -3.0X1 2.0X2 = 5.0
-4.0X0 2.0X1 -6.0X2 = 14.0
2.0X0 2.0X1 -4.0X2 = 8.0
| 2.0 -3.0
| -4.0 2.0 -6.0
| 2.0 2.0
-4.0
2.0
5.0 |
14.0
8.0 |
La matriz ampliada del sistema luego del pivoteo completo es:

| -6.0 2.0 -4.0
| 2.0 -3.0
| -4.0 2.0 2.0
14.0
2.0
5.0 |
8.0 |

| -6.0 2.0
-4.0
| 0.0 -2.3333333333333335
9.666666666666666 |
| 0.0 -1.1102230246251565E-16
1.4285714285714302 |
14.0
0.6666666666666667
4.857142857142857
Su solucin es:
X2 = -3.882352941176471 X1 = -4.058823529411764 X0 =
0.2941176470588239
-----------------------------------------------Utilizando la Regla de Cramer
2.0X0 -3.0X1 2.0X2 = 5.0
-4.0X0 2.0X1 -6.0X2 = 14.0
2.0X0 2.0X1 -4.0X2 = 8.0
La matriz A del sistema es:
| 2.0 -3.0
| -4.0 2.0 -6.0
| 2.0 2.0
-4.0
2.0
|
|
La matriz A0 del sistema es:

| 5.0 -3.0
2.0
| 14.0 2.0 -6.0 |
| 8.0 2.0
-4.0 |

| 2.0 5.0
2.0
| -4.0 14.0
| 2.0 8.0
-4.0
|
-6.0
|

| 2.0 -3.0
5.0
| -4.0 2.0 14.0 |
| 2.0 2.0
8.0
|
Su solucin es:
X0 = 0.29411764705882354
-3.8823529411764706
X1 = -4.0588235294117645
X2 =
Anexo: Programa en Java

Clase GaussSus (Eliminacin Gaussiana por sustitucin
hacia atrs)
import java.io.*;
public class GaussSus {
protected int n;
protected double a[][];
protected double b[];
protected double x[];
//--Constructores---------------------------------public GaussSus() {
n=0;
a=new double [n][n];
b=new double [n];
x=new double [n];
}
public GaussSus(int or){
n=or;
b=new double [n];
x=new double [n];
}
//--Setters---------------------------------------public void setN(int ene){
n=ene;
b=new double [n];
x=new double [n];
}
public void setA(double an[][]){
for (int i=0;i<n;i++){
for(int j=0; j<n; j++){
a[i][j]=an[i][j];
}
}
}
public void setB(double bn[]){
b[i]=bn[i];
}
}
//--Getters--------------------------------------public int getN(){
return n;
}
public double getA(int i, int j){
return a[i][j];
}
public double getB(int i){
return b[i];
}
public double getX(int i){
return x[i];
}
//--Mtodo de Gauss------------------------------public void gSus(){
//--Imprimiendo el Sistema-------------------System.out.println("El sistema ingresado es: ");
String men="";
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
men+=a[i][j]+"X"+j+"\t";
}
men+="= "+b[i]+"\n";
}
System.out.println(men);
//--Imprimiendo la Matriz Ampliada-------------------impMA("\nLa matriz ampliada del sistema es: ");
//--Eliminacin hacia Adelante---- //i - fila j - columna
for(int k=0; k<n-1;k++){
for(int i=k+1; i<n; i++){
double factor = a[i][k]/a[k][k];
for(int j=k; j<n; j++){
a[i][j]=a[i][j]-factor*a[k][j];
}
b[i]=b[i]-factor*b[k];
}
}
//--Imprimiendo la Matriz Ampliada Simplificada-------------------impMA("\nLa matriz ampliada luego de aplicar Gauss es: ");
//--Sustitucin hacia Atras-------------------x[n-1]=b[n-1]/a[n-1][n-1];
for(int i=n-2; i>=0;i--){
double sum = b[i];
for(int j=i+1;j<n;j++){
sum=sum-a[i][j]*x[j];
}
x[i]=sum/a[i][i];
}
//--Imprimiendo la Solucin-------------------System.out.println("Su solucin es: ");
men="";
men+="X"+i+" = "+x[i]+"\t";
}
}
//--Impresin de Matriz Ampliada--------------public void impMA(String titulo){
System.out.println(titulo);
String men="\n";
men+="|\t";
men+=a[i][j]+"\t";
}
men+=b[i]+"\t|\n";
}
}
// LECTURA DE ENTEROS
public static int leerEnt()throws IOException{
BufferedReader entrada = new BufferedReader(new
InputStreamReader(System.in));
int x;
try{
x=Integer.parseInt(entrada.readLine());
return x;
}
catch(NumberFormatException e) {
System.out.println("Ese dato no es vlido. Por Favor ingrese
otro: ");
x=leerEnt();
return x;
}
}
//-------------------------------------}
Clase GaussPSimple (Eliminacin Gaussiana con Pivoteo

Simple)
public class GaussPSimple extends GaussSus{
public GaussPSimple() {
super();
}
//--Mtodo de Gauss con Pivoteo Parcial------------------------------public void gSus(){
String men="";
men+=a[i][j]+"X"+j+"\t";
}
men+="= "+b[i]+"\n";
}
//--Pivoteo-----------------------------------------
pivoteo (0);
//--Imprimiendo la Matriz Ampliada luego de Pivotear-------------------impMA("\nLa matriz ampliada del sistema luego del pivoteo parcial
es: ");
}
}
}
double sum = b[i];
}
x[i]=sum/a[i][i];
}
men="";
men+="X"+i+" = "+x[i]+"\t";
}
}
// Pivoteo-----------------------------------------------public void pivoteo(int l){
int p=l;
double mayor=Math.abs(a[l][l]);
double aux;
for(int i=l+1; i<n; i++){
aux=Math.abs(a[i][l]);
if(aux>mayor){
mayor=aux;
p=i;
}
}
if(p!=l){
for(int i=l; i<n;i++){
aux = a[p][i];
a[p][i]=a[l][i];
a[l][i]=aux;
}
aux = b[p];
b[p]=b[l];
b[l]=aux;
}
}
}
Clase GaussPEsc (Eliminacin Gaussiana con Pivoteo

escalonado)
public class GaussPEsc extends GaussPSimple{
public GaussPEsc() {
super();
}
public void gSus(){
String men="";
men+=a[i][j]+"X"+j+"\t";
}
men+="= "+b[i]+"\n";
}
//--Imprimiendo la Matriz Ampliada luego de Pivotear-------------------//--Eliminacin hacia Adelante---- //i - fila j - columna
pivoteo (k);//--Pivoteo-------------------impMA("\nLa matriz ampliada del sistema luego del pivoteo "+
(k+1)+" parcial es: ");
//--Imprimiendo la Matriz Ampliada luego de
Pivotear-for(int i=k+1; i<n; i++){
}
}
}
//--Sustitucin hacia Atras--------------------
x[n-1]=b[n-1]/a[n-1][n-1];
double sum = b[i];
}
x[i]=sum/a[i][i];
}
men="";
men+="X"+i+" = "+x[i]+"\t";
}
}
}
Clase GaussPComp (Eliminacin Gaussiana con Pivoteo

Completo)
public class GaussPComp extends GaussPSimple{
private int xn[];
public GaussPComp() {
super();
}
public void gSus(){
xn = new int [n];
xn[i]=i;
}
String men="";
men+=a[i][j]+"X"+j+"\t";
}
men+="= "+b[i]+"\n";
}
//--Imprimiendo la Matriz Ampliada luego de Pivotear-------------------pivoteo (0);//--Pivoteo-------------------impMA("\nLa matriz ampliada del sistema luego del pivoteo
completo es: ");
//--Imprimiendo la Matriz Ampliada luego de Pivotear--

}
}
}
double sum = b[i];
}
x[i]=sum/a[i][i];
}
men="";
men+="X"+xn[i]+" = "+x[i]+"\t";
}
}
// Pivoteo-----------------------------------------------public void pivoteo(int l){
int p=l;
int c=l;
double mayor=Math.abs(a[l][l]);
double aux;
for(int i=l+1; i<n; i++){
for(int j=l+1; j<n; j++){
aux=Math.abs(a[i][j]);
if(aux>mayor){
mayor=aux;
p=i;
c=j;
}
}
}
if(p!=l){

aux = a[p][i];
a[p][i]=a[l][i];
a[l][i]=aux;
}
aux = b[p];
b[p]=b[l];
b[l]=aux;
}
if(c!=l){
aux = a[i][c];
a[i][c]=a[i][l];
a[i][l]=aux;
}
int m;
m=xn[l];
xn[l]=xn[c];
xn[c]=m;
}
}
}
Clase ReglaCramer (Solucin del sistema mediante la

Regla de Cramer)
import java.io.*;
public class ReglaCramer {
protected int n;
protected double a[][];
protected double an[][];
protected double b[];
protected double x[];
//--Constructores---------------------------------public ReglaCramer() {
n=0;
an=new double [n][n];
b=new double [n];
x=new double [n];
}
public ReglaCramer(int or){
n=or;
b=new double [n];
x=new double [n];
}
//--Setters---------------------------------------public void setN(int ene){
n=ene;

b=new double [n];
x=new double [n];
}
public void setA(double am[][]){
for(int j=0; j<n; j++){
a[i][j]=am[i][j];
}
}
}
public void setB(double bn[]){
b[i]=bn[i];
}
}
//--Getters--------------------------------------public int getN(){
return n;
}
public double getA(int i, int j){
return a[i][j];
}
public double getB(int i){
return b[i];
}
public double getX(int i){
return x[i];
}
//--Mtodo Regla de Cramer------------------------------public void rCramer(){
String men="";
men+=a[i][j]+"X"+j+"\t";
}
men+="= "+b[i]+"\n";
}
//--Imprimiendo la Matriz Ampliada-------------------impMA("\nLa matriz A del sistema es: ",a);
//Calculamos el vector X solucin---- //
auxMat(i);
x[i]= calDet(an)/calDet(a);
impMA("\nLa matriz A"+i+" del sistema es: ",an);
}
//--Imprimiendo la Solucin--------------------
System.out.println("Su solucin es: ");

men="";
men+="X"+i+" = "+x[i]+"\t";
}
}
//--Formacin de la matriz auxiliar-----------public void auxMat(int col){
if (j==col){
an[i][j]=b[i];
}
else{
an[i][j]=a[i][j];
}
}
}
}
//--Clculo de Determinante-------------------public double calDet(double am[][]){
double det=am[0][2]*(am[1][0]*am[2][1]-am[1][1]*am[2][0])am[1][2]*(am[0][0]*am[2][1]-am[0][1]*am[2][0])
+am[2][2]*(am[0][0]*am[1][1]-am[0][1]*am[1][0]);
return det;
}
//--Impresin de Matriz Ampliada--------------public void impMA(String titulo, double am[][]){
System.out.println(titulo);
String men="\n";
men+="|\t";
men+=am[i][j]+"\t";
}
men+="\t|\n";
}
}
// LECTURA DE ENTEROS
public static int leerEnt()throws IOException{
BufferedReader entrada = new BufferedReader(new
InputStreamReader(System.in));
int x;
try{
x=Integer.parseInt(entrada.readLine());
return x;
}
catch(NumberFormatException e) {
System.out.println("Ese dato no es vlido. Por Favor ingrese
otro: ");
x=leerEnt();
return x;
}
}
//-------------------------------------}
Clase Ej1 (Clase main en donde se realiza la carga y se

crean los objetos de las dems clases)
import java.io.*;
public class Ej1 {
public static void main(String[]args)throws IOException {
int n;
System.out.println("Programa para resolver sistemas de igual
cantidad de incgnitas que ecuaciones");
System.out.println("Ingrese la cantidad de incgnitas y ecuaciones
que tiene el sistema");
n=GaussSus.leerEnt();
double a [][];
a = new double [n][n];
double b[];
b= new double [n];
System.out.println("Para ecuaciones de la forma a1X1+a2X2+..
+anXn=bn");
System.out.println("Ingrese a"+j+" de la ecuacin
"+i);
a[i][j]=GaussSus.leerEnt();
}
System.out.println("Ingrese b"+i+" de la ecuacin "+i);
b[i]=GaussSus.leerEnt();
}
GaussSus gs = new GaussSus();
GaussPSimple gps = new GaussPSimple();
GaussPEsc gpe = new GaussPEsc();
GaussPComp gpc = new GaussPComp();
ReglaCramer rc = new ReglaCramer();
gs.setN(n);
gs.setA(a);
gs.setB(b);
gs.gSus();
System.out.println("------------------------------------------------");
System.out.println("Utilizando Gauss con Pivoteo parcial");
gps.setN(n);
gps.setA(a);
gps.setB(b);
gps.gSus();
System.out.println("Utilizando Gauss con Pivoteo parcial
Escalonado");
gpe.setN(n);
gpe.setA(a);
gpe.setB(b);
gpe.gSus();
System.out.println("Utilizando Gauss con Pivoteo Completo");
gpc.setN(n);
gpc.setA(a);
gpc.setB(b);
gpc.gSus();
System.out.println("Utilizando la Regla de Cramer");
rc.setN(n);
rc.setA(a);
rc.setB(b);
rc.rCramer();
}
}

AO3 Ej2 Campetella

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

AO3 Ej2 Campetella

Încărcat de

Drepturi de autor:

Formate disponibile

Actividad Obligatoria 3

sustitucin hacia atrs.

La matriz ampliada luego de aplicar Gauss es:

La matriz ampliada del sistema luego del pivoteo parcial es:

La matriz ampliada luego de aplicar Gauss es:

La matriz ampliada del sistema es:

La matriz ampliada del sistema luego del pivoteo 1 parcial es:

La matriz ampliada del sistema luego del pivoteo 2 parcial es:

La matriz ampliada luego de aplicar Gauss es:

La matriz ampliada del sistema luego del pivoteo completo es:

La matriz ampliada luego de aplicar Gauss es:

La matriz A0 del sistema es:

La matriz A1 del sistema es:

La matriz A2 del sistema es:

Anexo: Programa en Java

Clase GaussPSimple (Eliminacin Gaussiana con Pivoteo

Clase GaussPEsc (Eliminacin Gaussiana con Pivoteo

Clase GaussPComp (Eliminacin Gaussiana con Pivoteo

//--Eliminacin hacia Adelante---- //i - fila j - columna

for(int i=l; i<n;i++){

Clase ReglaCramer (Solucin del sistema mediante la

an=new double [n][n];

System.out.println("Su solucin es: ");

Clase Ej1 (Clase main en donde se realiza la carga y se

S-ar putea să vă placă și