Comment représenter une série mathématique

Question

Je veux construire une fonction, que l'un de ses arguments est la série {x[i], i = 0, 1, ..., inf}.

Par exemple: x_m = 1/(1+x_(m-1)), m=1,2....inf

Avec cette série, je veux vérifier pour chaque x [i], si elle satisfait une condition que je définirai (je ne sais pas pour qui n il sera satisfait).

par exemple:

Si x_0 < 5, je vais retourner la valeur de x_0.

Si non - je vais le vérifier pour x_1. Si x_1<5, je vais retourner la valeur de x_1.

et ainsi de suite ..

REMARQUE: x_1 besoin de connaître la valeur de x_0 pour ce calcul.

Il existe un moyen facile de représenter cette série en Java?

Answer 1

Voici une façon de représenter ce que vous essayez de faire. La fonction de somme que j'ai fournie ne fera sûrement pas l'affaire.

Pour un, votre séquence est une récurrence, et est implémentée ici récursivement. Vous voudrez le mémoriser. Je suggère d'ajouter quelque chose pour le faire en SeriesUtil. Plus important encore, vous ne pourrez évidemment pas avoir $ \ infinity $ comme limite supérieure. Comme vous le savez sûrement, c'est un problème non trivial. Cela dit, vous pouvez avoir différentes classes abstraites implémentant Series, telles que GeometricSeries, qui ont des solutions connues, et utilisent une stratégie appropriée étant donné le type de série.

interface Series { 
    double x(int m); 
} 

class ExampleSeries implements Series { 
    public double x(int m) { 
     if (m == 0) { 
      return 0; 
     } 

     return 1/(1 + x(m - 1)); 
    } 
} 

class SeriesUtil { 
    public static double sum(Series series, int lowerBound, int upperBound) { 
     int sum = 0; 
     for (int i = lowerBound; i <= upperBound) { 
      sum += x(i); 
     } 

     return sum; 
    } 
} 

Answer 2

Ceci est une réponse partielle seulement:

En tant que mathématicien, je dirais que vous voulez probablement définir une interface pour une série, avec la méthode double getElement(int m) et peut-être un peu plus. Ensuite, vous pouvez avoir différentes classes avec l'implémentation en fonction de la série. Vous pourriez avoir FormulaSeries ou RecursiveSeries où la série est donnée par une formule récursive (comme dans votre exemple). Cette classe peut stocker des valeurs intermédiaires en interne, pour une utilisation ultérieure (mémoization). En fonction de ce que vous visez, vous pouvez implémenter des séries partielles, où vous ne disposez que d'un nombre fini de valeurs connues, qui peuvent ensuite être stockées dans une liste ou un tableau.

Si nous nous concentrons sur le RecursiveSeries, vous voudrez peut-être stocker les valeurs calculées en interne dans un Map statique si la formule est vraiment difficile à calculer, et vous aurez besoin d'éléments plusieurs fois. Cela ne devrait pas être trop difficile à comprendre.

Answer 3

De toute évidence, Ray & Paxinum ont fourni le guide dont vous avez besoin. Tout ce que vous avez à faire est de l'ajuster en fonction de votre cas.

Mais dans le cas où c'est à des fins académiques et votre conférencier a besoin de voir votre script détaillé, vous pourriez considérer cela. Notez qu'une ArrayList est utilisée à la place d'un Array parce que les limites pour le premier peuvent être redéfinies contrairement à ce dernier. Vous pouvez copier et coller le code suivant et voir comment cela fonctionne. Pensez à l'éditer à vos spécifications si besoin est. J'ai aussi fourni des commentaires - ils expliquent les codes autant que possible. À votre santé!

import java.util.ArrayList; 
import java.util.Scanner; 

public class SeriesTest 
{ 

// This internal class "Index", will represent an index Object that holds a 
// value and returns the value when needed 
    class Index 
    { 
     private double idxElement; 

     private void setIdxElement(double value) 
     { 
      idxElement = value; 
     } 

     private double getIdxElement() 
     { 
      return idxElement; 
     } 
    } 

// Create an Object index of type Index (i.e the class defined above) 
Index index; 

// Create an ArrayList, x_ , that will reference the index Objects. 
ArrayList<Index> x_ = new ArrayList<Index>(); 

public void calculateResult() 
{ 
    System.out.println("How many elements do you want the series to have?"); 
    Scanner input = new Scanner(System.in); 
    int NoOfelements = input.nextInt(); 

    int value = 0; 

    // create a new instance of type Index 
    index = new Index(); 

    // set the element held by this index as 0(zero) 
    // You can set this to any value depending on your Series' requirements 
    index.setIdxElement(value); 

    /*add the index object to the ArrayList 
    *This represents your x_m 
    *Note - This references the index Object that holds the value = 0)*/ 
    x_.add(index); 

    /* To do the same thing for the rest of the elements using 
    * your specified equation ---> x_m = 1/[ 1 + x_(m-1) ]*/ 
    for (int m = 1; m < NoOfelements; m++) 
    { 
     index = new Index(); 
     // sets the value of the element referenced by the index object 
     // This represents your x_m = 1/[ 1 + x_(m-1) ] 
     index.setIdxElement(1/(1 + x_.get(m - 1).getIdxElement())); 

     // adds the index object to the ArrayList 
     x_.add(index); 
    } 
} 

public void displayResults() 
{ 
    // displays the series as referenced by the the ArrayList 
    // Note - ArrayList indexes start at 0(zero) 
    System.out.println("The series is:"); 
    for (int n = 0; n < x_.size(); n++) 
    { 
     System.out.printf("%.2f, ", x_.get(n).getIdxElement()); 
    } 
} 
public static void main(String[] args) 
{ 
    SeriesTest series = new SeriesTest(); 
    series.calculateResult(); 
    series.displayResults(); 
} 

}