Question concerning numerical evaluation

[pcfreak9000]

Hello there,

I need to evaluate a function with a certain precision. I first define some variables with the values i want to evaluatet he function at and then try to evaluate the function. My first approach was using ExprEvaluator.eval with "N[, 50]", but that would just give me the result in standard double precision (in hindsight i suppose that is just a fallback because of an exception in the arbitrary precision system?).

I then tried to use EvalEngine.evaluate directly, but that gives me an ArithmeticException: "Power of negative number; result would be complex". I tracked the problem down to an 1/ln(...). The ln itself works fine, but trying to get the inverse breaks it. Just evaluating the ln gives me -3...*10^-1. I suspect that exponent might cause the problem. I also tried to evaluate the inverse of that intermediate result, but that just gives me standard precision again (and doesn't break?).

At this point I am quite confused. Did I stumble upon a bug? Am I using the library (completely) wrong? And how do I get the result in my preferred precision?

[pcfreak9000]

Sure:

     public static void main(String[] args) {
        ExprEvaluator eval = new ExprEvaluator();
        //In my project, i read this from a file and dont know it compile-time
        String function = "(1/log(1-(a/u)))";
        eval.eval("a = 4.25/5");
        eval.eval("u = 2.95");
        //Gives a result but not in the specified precision
        //-2.94232029221608
        System.out.println(eval.eval("N[" + function + ", 50]"));
        try {
            //Crashes
            System.out.println(eval.getEvalEngine().evaluate("N[" + function + ", 50]"));
        } catch (Exception e) {
            //java.lang.ArithmeticException: Power of negative number; result would be complex
            System.err.println(e);
        }
        //This is just for experimenting, i still need to evaluate 'function'
        String function2 = "log(1-(a/u))";
        //Not the correct precision
        //-0.3398678256223512
        System.out.println(eval.eval("N[" + function2 + ", 50]"));
        //The precision seems to be fine with this one
        //-3.398678256223511869924307338065418655750732597009*10^-1
        System.out.println(eval.getEvalEngine().evaluate("N[" + function2 + ", 50]"));
    }

[axkr]

Symja uses apfloat for arbitrary precision arithmetic.

As you can see in the apfloat tutorial there are some caveats with the double constructor.

The recommendation is to use exact number input as much as possible.

For your example you can write:

    eval.eval("a = N[425/500, 50]");
    eval.eval("u = N[295/100, 50]");

Commit #aac80f0 should fix the error in Power#e2ApfloatArg() method for negative exponents.

Note: high precision calculations are available in Symja only for the functions which apfloat support.

import org.matheclipse.core.eval.ExprEvaluator;

public class Discussion206 {
  public static void main(String[] args) {
    ExprEvaluator eval = new ExprEvaluator();
    String function = "(1/log(1-(a/u)))";
    eval.eval("a = N[425/500, 50]");
    eval.eval("u = N[295/100, 50]");

    try {
      System.out.println(eval.eval("N[" + function + ", 50]"));
      System.out.println(eval.getEvalEngine().evaluate("N[" + function + ", 50]"));
    } catch (RuntimeException rex) {
      rex.printStackTrace();
    }

    try {
      String function2 = "log(1-(a/u))";
      System.out.println(eval.eval("N[" + function2 + ", 50]"));
      System.out.println(eval.getEvalEngine().evaluate("N[" + function2 + ", 50]"));
    } catch (RuntimeException rex) {
      rex.printStackTrace();
    }
  }
}

[pcfreak9000]

Thanks for the answer!