Corporación universitaria minuto de Dios

Facultad de ingeniería

Asignatura:

Diseño de Software

NRC: 2363

Docente
ING. OSCAR NAVARRO

Trabajo: “Taller de eficiencia”

Presentado por:

Andres Nicolas Tellez Calderon ID: 596017

Febrero 2020

Bogotá

ÍNDICE
 1. Introducción
2. Objetivo
3. Descripción
4. Desarrollo
_________________________________________________________________________

1. Introducción

Un algoritmo es considerado eficiente si su consumo de recursos está en la media o

por debajo de los niveles aceptables. Desde 1950 hasta la actualidad las
computadoras han tenido un avance impresionante tanto en poder computacional
como en la capacidad de memoria disponible, lo que indica que los niveles
aceptables de eficiencia en la actualidad hubieran sido inadmisibles 10 años atrás.
Los fabricantes de computadoras están frecuentemente lanzando nuevos modelos,
normalmente con mejor rendimiento. El costo de mejorar el software puede ser
bastante caro, por ello en muchos casos la forma más simple y barata de alcanzar
un mejor rendimiento es comprar una computadora con mejor rendimiento de por sí.

En la práctica existen otros factores que pueden afectar la eficiencia de un

algoritmo, tales como la necesidad de cierta precisión y/o veracidad. La forma en
que un algoritmo es implementado también puede tener un efecto de peso en su
eficiencia, muchos de los aspectos asociados a la implementación se vinculan a
problemas de optimización.

2. Objetivo

- Analizar y comprobar la eficiencia de un software.

- Comprender la recursividad.
- Buscar la solución más eficiente a la hora de programar.

3. Descripción

Lo que se va a realizar en este documento está basado a la eficiencia de un software;

analizando de qué forma lo podemos solucionar en este caso, se usó el problema de cómo
calcular el determinante de una matriz nxn. El objetivo es ver el tiempo de respuesta cuando
ingresamos una matriz muy grande y una pequeña.

4. Desarrollo

El primer porgrama que se realizó con un poco de ayuda de la red es este:

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
 */
package recursividad;

import java.util.Scanner;

/**
*
* @author Nicolas Tellez
*/
public class Recursividad {

public static void main(String args[]) {

Scanner leer = new Scanner(System.in);
int tamaño = 0;
int i, j;
do {
System.out.print("Digite el tamaño de la matriz: ");
tamaño = leer.nextInt();
if (tamaño < 0 || tamaño == 1) {
System.out.println("Dato invalido");
}
} while ((tamaño < 0) || (tamaño == 1));
System.out.println("La matriz es:");
int matriz[][] = new int[tamaño][tamaño];
for (i = 0; i < tamaño; i++) {
for (j = 0; j < tamaño; j++) {
matriz[i][j] = (int) (Math.random() * 10) - 5;
}
}

printmat(matriz);

System.out.println("El determinante de la matriz es: "+determin(matriz));

}

public static void printmat(int matriz[][]) {

int i, j;
for (i = 0; i < matriz.length; i++) {
for (j = 0; j < matriz.length; j++) {
System.out.print(String.valueOf(matriz[i][j]) + "\t");
}
System.out.println();
}
System.out.println();
}

public static int[][] submatrize(int matriz[][], int x, int y) {

int submatriz[][] = new int[matriz.length - 1][matriz.length - 1];
 int i, j, cur_x = 0, cur_y = 0;
for (i = 0; i < matriz.length; i++) {
if (i != x) {
cur_y = 0;
for (j = 0; j < matriz.length; j++) {
if (j != y) {
submatriz[cur_x][cur_y] = matriz[i][j];
cur_y++;
}
}
cur_x++;
}
}
return submatriz;
}

public static int determin(int matriz[][]) {

int deter = 0;
int i, mult = 1;
if (matriz.length > 2) {
for (i = 0; i < matriz.length; i++) {
deter += mult * matriz[i][0] * determin(submatrize(matriz, i, 0));
mult *= -1;
}
return deter;
} else {
return matriz[0][0] * matriz[1][1] - matriz[0][1] * matriz[1][0];
}
}
}

Al hacer pruebas con este problema con variables pequeñas me da una respuesta rápida
pero cuando lo aumentó tarda un poco más, cabe afirmar que el computador de tiene el
mejor hardware.
El resultado se dio en 4 segundos pero duplicado el tamaña de la matriz tenemos este
resultado:

El tiempo de respuesta de una matriz de 10x10 es de 30 segundos también cabe aclarar

que el rango para llenar la matriz es desde -5 hasta 5, se sigue probando el software.

El segundo programa que se realizó fue este:

Clase Cmatrices

/*
 * To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package Clases;

/**
*
* @author Nicolas Tellez
*/
public class Cmatrices {

//meto que calcule la determinante

public double Determinante(int i, double[][] matriz) {

if (matriz.length == 2) {
double deter = matriz[0][0] * matriz[1][1] - matriz[0][1] * matriz[1][0];

return deter;
} else {
double deter = 0;

for (int j = 0; j < matriz.length; j++) {

double[][] temp = this.SubMatriz(i, j, matriz);

deter = deter + Math.pow(-1, i + j) * matriz[i][j] * this.Determinante(0, temp);

return deter;
}

//claculo de submatriz eliminado i, j

private double[][] SubMatriz(int i, int j, double[][] matriz) {

double[][] temp = new double[matriz.length - 1][matriz.length - 1];

int count1 = 0;
int count2 = 0;

for (int k = 0; k < matriz.length; k++) {

if (k != i) {
count2 = 0;
for (int l = 0; l < matriz.length; l++) {
if (l != j) {
temp[count1][count2] = matriz[k][l];
 count2++;
}

count1++;
}

return temp;

//metodo para calcular la adjunta de una matrzi

public double[][] AdjuntaMatriz(double[][] matriz) {

double[][] tempAdjunta = new double[matriz.length][matriz.length];

for (int i = 0; i < tempAdjunta.length; i++) {

for (int j = 0; j < tempAdjunta.length; j++) {
double[][] temp = this.SubMatriz(i, j, matriz);

double elementoAdjunto = Math.pow(-1, i + j) * this.Determinante(0, temp);

tempAdjunta[i][j] = elementoAdjunto;

return tempAdjunta;

//metodo para obtener la transpuesta de la matriz

public double[][] TransouestaMatriz(double[][] matriz) {

double[][] tempTranspuesta = new double[matriz.length][matriz.length];

for (int i = 0; i < tempTranspuesta.length; i++) {

for (int j = 0; j < tempTranspuesta.length; j++) {

tempTranspuesta[i][j] = matriz[j][i];

}
 }

return tempTranspuesta;

Clase Matrices

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package matrices;

import Clases.Cmatrices;
import java.util.Scanner;

/**
*
* @author 2012
*/
public class Matrices {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner leer = new Scanner(System.in);
int tamaño = 0;
int i, j;
do {
System.out.print("Digite el tamaño de la matriz: ");
tamaño = leer.nextInt();
if (tamaño < 0 || tamaño == 1) {
System.out.println("Dato invalido");
}
} while ((tamaño < 0) || (tamaño == 1));

double matriz[][] = new double[tamaño][tamaño];

for (i = 0; i < tamaño; i++) {
for (j = 0; j < tamaño; j++) {
matriz[i][j] = (int) (Math.random() * 10) - 5;
}
}
 Cmatrices mat = new Cmatrices();

try {

double determinate = mat.Determinante(0, matriz); //calculando la determinate

double[][] MatAdjunta = mat.AdjuntaMatriz(matriz);

double[][] MatTrans = mat.TransouestaMatriz(MatAdjunta);

System.out.println("la matriz es:");

for (i = 0; i < matriz.length; i++) {

for (j = 0; j < matriz.length; j++) {
System.out.print(matriz[i][j] + "\t");

System.out.println("");

}
System.out.println("la determinante es:" + determinate);
if (determinate == 0) {

System.out.println("No existe inversa de la matriz");

} catch (Exception e) {
System.out.println("error->" + e.getMessage());
}