Fonction Zêta de Riemann en Java-Récursivité Infinie avec Forme Fonctionnelle

Ok bien nous avons compris que pour cette fonction particulière, puisque cette forme n'est pas en fait une série infinie, nous ne pouvons pas approximer en utilisant la récursivité. Cependant, la somme infinie de la série Zêta de Riemann (1\(n^s) where n = 1 to infinity) pourrait être résolue par cette méthode.

De plus, cette méthode pourrait être utilisée pour trouver toute somme, produit ou limite de série infinie.

Si vous exécutez le code que vous avez actuellement, vous obtiendrez une récursivité infinie comme 1-(1-s) = s (par exemple 1-s = t, 1-t = s donc vous allez juste basculer entre deux valeurs de s infiniment).

Ci-dessous, je parle de la somme des séries. Il semble que vous calculiez le produit de la série à la place. Les concepts ci-dessous devraient fonctionner pour l'un ou l'autre.

En plus de cela, la fonction Zêta de Riemann est une série infinie. Cela signifie qu'il n'a qu'une limite et n'atteindra jamais une somme vraie (en temps fini) et que vous ne pouvez donc pas obtenir une réponse exacte récursivité.

Cependant , si vous introduisez un facteur "seuil", vous pouvez obtenir une approximation aussi bonne que vous le souhaitez. La somme augmentera/diminuera à mesure que chaque terme sera ajouté. Une fois la somme stabilisée, vous pouvez quitter la récursivité et retourner votre somme approximative. "Stabilisé" est défini en utilisant votre facteur de seuil. Une fois que la somme varie d'un montant inférieur à ce facteur seuil (que vous avez défini), votre somme s'est stabilisée.

Un seuil plus petit conduit à un meilleure approximation, mais aussi plus long temps de calcul.

(Note: cette méthode ne fonctionne que si votre série converge, si elle a une chance de ne pas converger, vous pouvez également construire une variable maxSteps pour cesser l'exécution si la série n'a pas convergé à votre satisfaction après maxSteps étapes de récursivité.)

Voici un exemple d'implémentation, notez que vous devrez jouer avec threshold et {[6] } pour déterminer les valeurs appropriées:

/* Riemann's Functional Equation
 * threshold - if two terms differ by less than this absolute amount, return
 * currSteps/maxSteps - if currSteps becomes maxSteps, give up on convergence and return
 * currVal - the current product, used to determine threshold case (start at 1)
 */
public static double riemannFuncForm(double s, double threshold, int currSteps, int maxSteps, double currVal) {
    double nextVal = currVal*(Math.pow(2, s)*Math.pow(Math.PI, s-1)*(Math.sin((Math.PI*s)/2))*gamma(1-s)); //currVal*term
    if( s == 1.0)
        return 0;
    else if ( s == 0.0)
        return -0.5;
    else if (Math.abs(currVal-nextVal) < threshold) //When a term will change the current answer by less than threshold
        return nextVal; //Could also do currVal here (shouldn't matter much as they differ by < threshold)
    else if (currSteps == maxSteps)//When you've taken the max allowed steps
        return nextVal; //You might want to print something here so you know you didn't converge
    else //Otherwise just keep recursing
        return riemannFuncForm(1-s, threshold, ++currSteps, maxSteps, nextVal);
    }
}

Ce n'est pas possible.

La forme fonctionnelle de la fonction Zêta de Riemann est --

zeta(s) = 2^s pi^(-1+s) Gamma(1-s) sin((pi s)/2) zeta(1-s)

Ceci est différent de l'équation standard dans laquelle une somme infinie est mesurée de 1/k^s pour tout k = 1 à k = infini. Il est possible d'écrire cela comme quelque chose de similaire à --

// Standard form the the Zeta function.
public static double standardZeta(double s) {
    int n = 1;
    double currentSum = 0;
    double relativeError = 1;
    double error = 0.000001;
    double remainder;

    while (relativeError > error) {
        currentSum = Math.pow(n, -s) + currentSum;
        remainder = 1 / ((s-1)* Math.pow(n, (s-1)));
        relativeError =  remainder / currentSum;
        n++;
    }
    System.out.println("The number of terms summed was " + n + ".");
    return currentSum;
}

La même logique ne s'applique pas à l'equation fonctionnelle (ce n'est pas une somme directe, c'est une relation mathématique). Cela nécessiterait une façon plutôt intelligente de concevoir un programme pour calculez les valeurs négatives de Zêta (s)!

L'interprétation littérale de ce code Java est ---

// Riemann's Functional Equation
public static double riemannFuncForm(double s) {
double currentVal = (Math.pow(2, s)*Math.pow(Math.PI, s-1)*(Math.sin((Math.PI*s)/2))*gamma(1-s));
if( s == 1.0)
    return 0;
else if ( s == 0.0)
    return -0.5;
else
    System.out.println("Value of next value is " + nextVal(1-s));
    return currentVal;//*nextVal(1-s);
}

public static double nextVal(double s)
{
    return (Math.pow(2, s)*Math.pow(Math.PI, s-1)*(Math.sin((Math.PI*s)/2))*gamma(1-s));
}

public static double getRiemannSum(double s) {
    return riemannFuncForm(s);
}

Tester sur trois ou quatre valeurs montre que cela ne fonctionne pas. Si vous écrivez quelque chose de similaire à --

// Riemann's Functional Equation
public static double riemannFuncForm(double s) {
double currentVal = Math.pow(2, s)*Math.pow(Math.PI, s-1)*(Math.sin((Math.PI*s)/2))*gamma(1-s); //currVal*term
if( s == 1.0)
    return 0;
else if ( s == 0.0)
    return -0.5;
else //Otherwise just keep recursing
    return currentVal * nextVal(1-s);
}

public static double nextVal(double s)
{
    return (Math.pow(2, s)*Math.pow(Math.PI, s-1)*(Math.sin((Math.PI*s)/2))*gamma(1-s));
}

J'ai mal interprété comment faire cela à travers les mathématiques. Je devrai utiliser une approximation différente de la fonction zêta pour les valeurs inférieures à 2.