Resolver integral de Riemann en java (integral por aproximación)

[Eva]

AYY..Por favor necesito a alguien que sepa de matematica y de programacion en Java...

Despues de resolver el comportamiento de ecuaciones necesito crear una clase Integral de Area que se resuelva mediante la Integral de Riemann..Lo que hice es lo siguiente:

Código: [Seleccionar]

package ar.edu.unlam.tallerweb.ecuaciones;

/**
 * Representa la abstraccion del calculo de la integral bajo
 * la curva proporcionada.
 *
 */
public class IntegralDeArea {

/**
* Calcula el area bajo la curva, utilizando el metodo de las sumas
* de Riemann entre los dos puntos dados.
*
* @param ecuacion
* @param inicio
* @param fin
* @param incremento
* @return el Area bajo la curva
*/

private Ecuacion ec;
private Double ini;
private Double fin;
private Double increm;

public IntegralDeArea(){
this.ec=ec;
this.ini=ini;
this.fin=fin;
this.increm=increm;
}

public Double calcular(Ecuacion ecuacion, Double inicio,Double fin, Double incremento) {

Double area = null;
//throw new RuntimeException("No implementado");
return area;
}

}

Lo que me hace falta resolver es cual seria el comportamiento de la clase en si ya que lei sobre Riemann y no me queda claro como llevarlo a codigo.

Desde ya les agradezco la coloboracion y si sugieren cambios en el codigo los hago esto solo es una estructura que se me ocurrio ademas despues lo tengo que probar mediante Tests!!

[Mastermind]

Tendrías que decir qué metodología de resolución hay que seguir. La idea se resume en esta imagen:

Pero claro, habría que especificar un poco más.

De modo orientativo yo plantearía lo siguiente:


//Método que nos permita calcular el área aproximada bajo la curva
public Double calcular(Ecuacion ecuacion, Double inicio,Double fin, Double incremento) {
double posicionCalculo = inicio;
double areaParcial;
double areaAcumulada;

while (posicionCalculo <= fin) {
   areaParcial = valorEcuacion (ecuacion, posicionCalculo);
   areaAcumulada = areaParcial + AreaAcumulada;
   posicionCalculo = posicionCalculo + incremento;
}
return areaAcumulada;

}



Te hace falta tener un método auxiliar que te diga cuál es el valor de la función ecuación para un valor de x dado.

public double valorEcuacion (Ecuacion ecuacion, double valorDex) {

double resultado = 0;
//Aquí tienes que calcular el resultado de la ecuación para un valor de x
// Por ejemplo si la ecuación es 3*x^2 -1 y le pasas x=3, el resultado a devolver será 3*9-1 = 26

return resultado;

}   

[foxternoster]

Hola Mastermind, en la solución que has propuesto se toma el área correspondiente al rectángulo definido por la coordenada izquierda del intervalo, yo vería más correcto coger el área del punto medio del intervalo.

[Eva]

Yo estuve buscando informacion y los graficos son tal cual lo paso Mastermind pero todavia no me queda claro como es la ecuacion o formula que se utiliza para resolver una Integral de Area asi que agradeceria que me indiquen como probar pasando valores mediante tests..Por otro lado el While no se bien que es lo que condiciona, no digo que esta mal porque de hecho a mi ni siquiera se me ocurre como hacerlo...solamente me gustaria que me explicasen porque esta pensado con esa logica..o por que foxternoster sugiere que se puede hacer de otra manera.

[Mastermind]

Pues foxternoster tiene razón, habría distintas maneras de resolver esto. Lo primero que hay que tener claro es el concepto de integral, ya que la integral de Riemann lo único que hace es calcular la integral por aproximación. Claro que a medida que los intervalos se hacen más pequeños la solución es más exacta hasta que cuando los intervalos tienden a dx la solución de Riemann tendería a la solución real.

Explicar el concepto de integral no es trivial. La integral de una función devuelve el área bajo la función, más o menos como está representado en el gráfico. La integral de una función f(x) es aquella función cuya derivada devuelve f(x). Así para hacer pruebas tendrías que definir funciones concretas. Por ejemplo para f(x) = x^2 la integral sería h(x) = (1/3) * (x^3) ; Si derivamos h(x) obtenemos 3 * (x^2) / 3 = x^2.

Ahora entre dos puntos concretos como x=0 y x=2 la integral se resuelve como h(2) - h(0) = (1/3) * (2^3) - (1/3) * (0^3) = 8/3 = 2,6667

Si calculamos la integral de Riemann con inicio = 0, fin = 2, incremento = 0.5, la solución será por ejemplo 3,25. Si hacemos más pequeño el incremento la solución mejorará hasta que para valores de incremento muy pequeños llegamos a aproximadamente 2,67.

Esto hay que entenderlo para saber cómo enfocar este problema porque difícilmente se podrá programar esto si no se tienen estas nociones de integración.

[Eva]

Ok!!! Ahora me quedo mas claro...Muchas Gracias...

Ah!!! Al final en la clase que tengo EcuacionPolinomica.java la implemente mal y me pasaron las siguientes condiciones:

Constructor parametrizado donde el parametro coeficientes siendo coeficientes[0] el valor que corresponde al termino independiente.
Por lo que el f(x) deberia ser:
        f(x) = coeficientes[0]
          + coeficientes[1]*x
           + coeficientes[2]*x^2
           + ...
En conlusion se le deberia pasar valores de la siguiente manera
coeficientes = [1, 0, 2, 1, -1]
 f(x) = 1*x^0 + 0 * x^1 + 2 * x^2 + 1 * x^3 - 1 * x^4


Yo estaba trabajando pasando valores uno por uno, es decir tenia variables(a,b,c,etc) a las que mediante test les pasaba numeros pero lo que quiere el profesor, por lo que entiendo, es pasarlos mediante un Array

private List<Double> coeficientes = new ArrayList<Double>();
   
   public EcuacionPolinomica(List<Double> coeficientes) {
      
      throw new RuntimeException("No implementado");

   }
   
   /**
    * Devuelve el resultado de evaluar f(x)
    *
    * @param x la variable
    *
    */
   public Double resolver(Double x) {

      throw new RuntimeException("No implementado");

//creo que deberia tener un for para recorrerlo pero no se como implementarlo
      Double valorf;
      valorf = coeficientes[0]*(x*x*x*x)+coeficientes[1]*(x*x*x)+coeficientes[2](x*x)+coeficientes[3]*x+coeficientes[4];
   return valorf;
}

No se si esta bien.. acepto sugerencias de cambio de codigo.

[Mastermind]

Tal y como lo estás escribiendo los coeficientes deberían ir en un array, no en una lista. Mírate cómo se trabaja con arrays y la diferencia con las listas aquí: https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=635:arrays-o-arreglos-java-ejemplos-de-objetos-y-tipos-primitivos-length-tipos-de-colecciones-cu00669b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188

El código trabajado con arrays

private double [] coeficientes; //Uso el tipo primitivo double
   
   public EcuacionPolinomica(double[] coeficientes) {
     
      throw new RuntimeException("No implementado");

   }
   
   /**
    * Devuelve el resultado de evaluar f(x)
    *
    * @param x la variable
    *
    */
   public double resolver(double x) {

      throw new RuntimeException("No implementado");
}


Cómo recorrer los arrays también lo tienes en el enlace anterior 

[Eva]

Hola muchas gracias por la informacion, pero me dijeron que lo tengo que hacer con ArrayList y me comentaron lo siguiente:
que en la ecuación polinómica vos tenés que tener en cuenta que le pasás una lista de coeficientes, los cuales tenés que ir iterando con un for o while y tenés que ir multiplicando cada coeficiente de la lista por el valor de x (parámetro que recibe la funcion resolver) elevado a la n (n equivale a la cantidad de valores que tiene la lista) por ejemplo: si la lista que tiene la EcuacionPolinomica es [10,11,12,13,14] vos tenés que lograr resolver, con la lógica del algoritmo anterior, lo siguiente:

suponé que la función resolver es llamada de la siguiente manera= ecuacionPolinomica.resolver(5)
, te quedaría así la lógica:

10 * 5^0 + 11 * 5^1 + 12 * 5^2 + 13 * 5^3 + 14 * 5^4

Fijate que acá terminé elevando al valor de x (el que recibe por parámetro la función resolver) hasta 4 porque la lista tiene 5 valores, por ende tiene exponente máximo 4   (0-1-2-3-4)

Y yo lo que hice fue lo siguiente:
public Double resolver(Double x) {
      List<Double> coeficientes = new ArrayList();
      Double a;Double b;Double c;Double d;Double e;
      coeficientes.add(a);
      coeficientes.add(b);
      coeficientes.add(c);
      coeficientes.add(d);
      coeficientes.add(e);
      
      for(int i=0;i <= coeficientes.size();i++){
         /*
mi problema es en el for no se como definirle que a mi primer valor del array lo tiene que multiplica por x^4, el segundo a x^3,el tercero a x^2,etc. Me doy cuenta que es re facil pero no me sale implementarlo

*/
      }
      throw new RuntimeException("No implementado");
      }

[Mastermind]

Hola Eva  No acabo de entender por qué declarar los coeficientes dentro del método resolver, cuando los coeficientes son propios del objeto, no del método  . Yo lo he planteado así:


import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

//Clase ecucación polinómica

public class EcuacionPolinomica {
    private List<Double> coeficientes;

    public EcuacionPolinomica (List<Double> coeficientes) {
        this.coeficientes = new ArrayList<Double>(coeficientes);
    }

    public Double resolver (Double parametroPotencia){
        Double resultado=0.0;
        for (int i=0; i<coeficientes.size(); i++){
            resultado = resultado + coeficientes.get(i) * Math.pow(parametroPotencia, i);
            System.out.println ("El resultado parcial es " + resultado); // COMPROBACIÓN
        }
        return resultado;
    }
}



//CLASE PARA PROBAR
import java.util.ArrayList;

public class Test {

    public static void main (String[] Args) {

        ArrayList <Double> coef1 = new ArrayList<Double>();
        coef1.add(3.0);
        coef1.add(5.5);
        coef1.add(1.0);

        EcuacionPolinomica ecu1 = new EcuacionPolinomica(coef1);

        ecu1.resolver(1.0);
        ecu1.resolver(2.0);
        ecu1.resolver(3.0);
    }
}

Si ejecutamos vemos cómo se va construyendo el resultado:

El resultado parcial es 3.0
El resultado parcial es 8.5
El resultado parcial es 9.5
El resultado parcial es 3.0
El resultado parcial es 14.0
El resultado parcial es 18.0
El resultado parcial es 3.0
El resultado parcial es 19.5
El resultado parcial es 28.5

[Eva]

Hola!!!!
Muchisimas gracias!!!
Sabes que el for lo habia armado bien pero le pasaba mal los valores!!!

Fue de mucha ayuda!!! 

Para el que le interesa pude encontrar un video tutorial que explicaba la Suma de Riemman y lo resolvi de esta manera:

Código: [Seleccionar]

public Double calcular(Ecuacion ecuacion, Double inicio, Double fin,
Double incremento) {

Double resultado = 0.0;
Double areaParcial = 0.0;
if (ecuacion.equals(null) || inicio.equals(null) || fin.equals(null)
|| incremento.equals(null)) {
throw new RuntimeException("No implementado");
}
else{
Double segundoIncremento = incremento.doubleValue()/2;
Double totalIteraciones = fin.doubleValue() - inicio.doubleValue() ;
totalIteraciones = totalIteraciones/incremento.doubleValue();

for(int i=0;i<totalIteraciones;i++){
areaParcial = inicio.doubleValue()+(ecuacion.resolver(areaParcial+segundoIncremento));
resultado = resultado.doubleValue()+ecuacion.resolver(incremento);
}
return Math.abs((resultado.doubleValue()*incremento.doubleValue()));
}

}

Cualquier cosa explico el metodo porque estoy segura que lo entendi jeje!!!