Java. Рекурсивный метод вычисления 10*x + exp(x) + exp(-x)

public static void libraryFunction(int x){
        double function = 10*x + Math.exp(x) + Math.exp(-x);
        System.out.println(function);
    }

public static void ownLoopFunction(int x){
        double tempFact = 1;
        int n = 1;
        double power = x;
        double tempPower = power;
        double function = 10 * x + 2;
        do{
            tempFact*= n;
            function += (tempPower/tempFact) + (Math.pow(-1, n) * (tempPower/tempFact));
            tempPower *= power;
 
            n++;
        }while (tempPower/tempFact >= 0.00001);
 
        System.out.println(function);
    }

public static void ownRecursionFunction(int x){
        double power = x;
        double function = 10 * x + 1;
        function += (power/1) + (-power/1) * recursion(power, 2, 2,power*power);
        System.out.println(function);
    }
 
    public static double recursion(double power, double factorial, double tempFactorial, double tempPower){
        if(tempPower/tempFactorial >= 0.000001){
            return 1 + (power/factorial) * recursion(power, factorial++, factorial*tempFactorial, tempPower*power);
        }else return 1;
    }

private static int recursionX(int x){
        if(x == 1) return 10;
        int result = 10 + recursionX(x-1);
        return result;
    }
 
    private static double recursionExpX(int x){
        if(x == 1) return Math.E;
        double result = Math.E * recursionExpX(x - 1);
        return result;
    }
 
    public static double recursionExpression(int x){
        return recursionX(x) + recursionExpX(x) + 1/recursionExpX(x);
    }

private static long fact(int x){
        long result = 1;
        for(int i = 1; i <= x; i++){
            result *= i;
        }
        return result;
    }
 
    private static double taylor(int x){
        int k = 0;
        double result = 0;
        double partResult = 1;
 
        while(partResult > 0.001){
            partResult = Math.pow(x,k)/fact(k);
            result += partResult;
            k++;
        }
        return result;
    }
 
    public static double taylorExpression(int x){
        return 10 * x + taylor(x) + 1/taylor(x);
    }

    public static double libraryFunction(double x) {
        return 10 * x + Math.exp(x) + Math.exp(-x);
    }
 
    public static double loopFunction(double x) {
        int n = 1;
        double nFact = 1;
        double function = 10 * x + 2;
        while (pow(x, n) / nFact >= 0.00001) {
            function += (pow(x, n) / nFact) + (pow(-1, n) * (pow(x, n) / nFact));
            nFact *= ++n;
        }
        return function;
    }
 
    public static double recursionFunction(double x) {
        int n = 1;
        double function = 10 * x + 2;
        function += (x / 1) * rec(x, n + 1) + (-(x / 1) * recNeg(x, n + 1));
        return function;
    }
 
    private static double recNeg(double x, double n) {
        if (pow(x, n) / fact(n) >= 0.00001) {
            return 1 - (x / n) * recNeg(x, n + 1);
        } else return 1;
    }
 
    private static double rec(double x, double n) {
        if (pow(x, n) / fact(n) >= 0.00001) {
            return 1 + (x / n) * rec(x, n + 1);
        } else return 1;
    }
 
    private static double pow(double a, double b) {
        return Math.pow(a, b);
    }
 
    private static double fact(double n) {
        return (n == 0) ? 1 : n * fact(n - 1);
    }