Напишите программу для вычисления суммы ряда, соответствующего своему варианту

public class Main {
    public static void main(String[] args) {
        final InputArgs inputArgs = InputArgs.fromArgs(args);
 
        final double x = inputArgs.getX();
        final double precision = inputArgs.getPrecision();
 
        System.out.println("Result is :\n " + calculate(x, precision)
            + "\ne^" + x + " =\n " + Math.exp(x));
    }
 
    private static double calculate(final double x, final double precision) {
        long n = 0;
        double f = FunctionCalculator.function(x, n);
        double result = f;
 
        while (f > precision) {
            f = FunctionCalculator.function(x, ++n);
            result += f;
        }
 
        return result;
    }
 
    private static class FunctionCalculator {
        public static double function(final double x, final long n) {
            final BigDecimal a = BigDecimal.valueOf(Math.pow(x, n * 1.0));
            final BigDecimal b = new BigDecimal(factorial(n));
            return a.divide(b, 20, BigDecimal.ROUND_CEILING).doubleValue();
        }
 
        private static BigInteger factorial(final long n) {
            return recursiveFactorial(1, n);
        }
 
        private static BigInteger recursiveFactorial(final long start, final long n) {
            long i;
            if (n <= 16) {
                BigInteger r = new BigInteger(String.valueOf(start));
                for (i = start + 1; i < start + n; i++)
                    r = r.multiply(BigInteger.valueOf(i));
                return r;
            }
            i = n / 2;
            return recursiveFactorial(start, i).multiply(recursiveFactorial(start + i, n - i));
        }
    }
 
    private static class InputArgs {
        private double x;
        private double precision;
 
        public static InputArgs fromArgs(final String[] args) {
            if (args.length == 2) {
                try {
                    return new InputArgs(Double.parseDouble(args[0]), Double.parseDouble(args[1]));
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Provided argument is not a double value", e);
                }
            } else
                throw new IllegalArgumentException("Invalid arguments count provided");
 
        }
 
        public double getPrecision() {
            return precision;
        }
 
        public double getX() {
            return x;
        }
 
        private InputArgs(final double x, final double precision) {
            this.x = x;
            this.precision = precision;
        }
    }
}