Дзета-функция Римана в Java-бесконечная рекурсия с функциональной формой

хорошо, мы выяснили, что для этой конкретной функции, поскольку эта форма на самом деле не является бесконечным рядом, мы не можем аппроксимировать с помощью рекурсии. Однако бесконечная сумма Дзета-рядов Римана (1\(n^s) where n = 1 to infinity) может быть решена с помощью этого метода.

кроме того, этот метод может быть использован, чтобы найти сумма, произведение или предел любого бесконечного ряда.

если вы выполняете код, который у вас есть, вы получите бесконечную рекурсию как 1-(1-s) = s (например,1-s = t, 1-t = s таким образом, вы будете просто переключаться между двумя значениями s бесконечно).

ниже я говорю о сумме ряда. Похоже, вместо этого вы вычисляете произведение ряда. Приведенные ниже концепции должны работать в обоих случаях.

кроме того, Дзета-функция Римана является бесконечные сериалы. Это означает, что он имеет только предел и никогда не достигнет истинной суммы (в конечное время), и поэтому вы не можете получить точную ответ через рекурсию.

, если вы введете "пороговый" фактор, вы можете получить приближение, которое так хорошо, как вам нравится. Сумма будет увеличиваться/уменьшаться по мере добавления каждого члена. Как только сумма стабилизируется, вы можете выйти из рекурсии и вернуть приблизительную сумму. "Stabilized"определяется с использованием порогового коэффициента. Как только сумма изменяется на сумму, меньшую этого порогового коэффициента( который вы определили), ваша сумма имеет стабилизированный.

меньший порог приводит к лучшему приближению, но и к большему времени вычисления.

(Примечание: этот метод работает только в том случае, если ваша серия сходится, если у нее есть шанс не сходиться, вы также можете захотеть построить в maxSteps переменная для прекращения выполнения, если серия не сошлась к вашему удовлетворению после maxSteps шагов рекурсии.)

вот пример реализации, обратите внимание, что вам придется играть с threshold и maxSteps для определения соответствующих значений:

/* 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);
    }
}

это невозможно.

функциональная форма дзета-функции Римана --

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

это отличается от стандартного уравнения, в котором бесконечная сумма измеряется от 1/k^s для всех k = 1 до K = бесконечности. Можно написать это как нечто подобное --

// 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;
}

та же логика не применима к функциональному уравнению (это не прямая сумма, это математическая зависимость). Это потребовало бы довольно умного способа разработка программы для расчета отрицательных значений Дзета(ы)!

буквальная интерпретация этого кода Java - - -

// 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);
}

тестирование на трех или четырех значениях показывает, что это не работает. Если вы напишете что-то похожее на --

// 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));
}

Я неправильно понял, как это сделать с помощью математики. Мне придется использовать другое приближение дзета-функции для значений меньше 2.