Package com.singularsys.extensions.fastmatrix

Class MrpEval

java.lang.Object
com.singularsys.extensions.fastreal.AbstractEval
com.singularsys.extensions.fastmatrix.MrpEval
All Implemented Interfaces:
GenericVisitor<Void,Void,ParseException>, JepComponent, Serializable
public final class MrpEval extends AbstractEval
A fast evaluation algorithm for equations using Vectors and Matrix over the Doubles. This is based around reverse polish notation (hence the name M Rp Eval) and is optimised for speed at every opportunity.

To use do 

 Jep jep = new Jep();
 MRpEval rpe = new MRpEval(j);
 DimensionVisitor       dimV = new DimensionVisitor(jep);
 
 Node node = jep.parse(...); 
 dimV.visit(node);
 MRpCommandList list = rpe.compile(node);
 MRpRes rpRes = rpe.evaluate(list);
 System.out.println(rpRes.toString());
 MatrixI mat = rpRes.toVecMat();
 rpe.cleanUp();

The real use of this class is when an equation (or set of equations) need to be repeatedly evaluated with different values for the variables. MRpEval use an internal store for variable values different from those used in the main Jep classes. Changes in the Jep variable values, say by calling Jep.setVarValue, are reflected in changes in MRpEval variables, (the converse does not hold). A more efficient way is to use int ref=getVarRef(var) to return an index number of the variable and then calling setVarVal(ref,value) to set its value. For example 

 MRpCommandList list = rpe.compile(node);
 int ref = rpe.getVarRef(j.getVar("x"));
 for(double x=-1.;x<1.001;x+=0.1) {
      rpe.setVarVal(ref,x);
      rpe.evaluate(list);
 }

Combining mrpe with Differentiation requires special techniques to cope with that fact that internal equations are used

The compile methods converts the expression represented by node into a string of commands. For example the expression "1+2*3" will be converted into the sequence of commands 

 Constant no 1 (pushes constant onto stack)
 Constant no 2
 Constant no 3
 Multiply scalars (multiplies last two entries on stack)
 Add scalars (adds last two entries on stack)
The evaluate method executes these methods sequentially using a stack (actually a set of stacks) and returns the last object on the stack.

A few cautionary notes: the values returned by evaluate are references to internal variables, their values will change at the next call to compile or evaluate. It is very unlikely to be thread safe. It only works over doubles; expressions with complex numbers or strings will cause problems. It is tuned to work best for expressions involving scalars and 2, 3 and 4 dimensional vectors and matrices, larger vectors and matrices will be noticeably slower. The cleanUp function should be used when you no longer need the evaluator.

Implementation notes A lot of things have been done to make it as fast as possible:

  • Everything is final which maximises the possibility for in-lining.
  • All object creation happens during compile.
  • All calculations done using double values.
  • Vectors and Matrices are instances of VnObj and MatObj optimised for speed.
  • The values of variables are kept on local arrays for fast access.

Scalars, Vectors and matrices used during evaluation are kept in three store classes. Each Store class contains a stack, a heap and a array of variable values. During evaluation objects are pushed and popped from the stack when a new object is needed it is taken from the heap.

Limitations

There is a limit to the number of function calls to non-inbuilt functions. A maximum of 65536 calls to external unary functions.

Since Jep 4.1, extension 2.2, the parent class now implements GenericVisitor and some method signatures have changed to be more specific.

See Also:

  • Constructor Details

    • MrpEval

      public MrpEval(Jep mjep)
      Constructor using the MatrixFactory from the jep instance
      Parameters:
      mjep - jep instance

    • MrpEval

      public MrpEval(Jep mjep, MatrixFactoryI mfac)
      Constructor using a supplied MatrixFactory
      Parameters:
      mjep - jep instance
      mfac - matrix factory instance

    • MrpEval

      public MrpEval(Jep mjep, MatrixFactoryI mfac, int indexShift)
      Constructor using a supplied function table
      Parameters:
      mjep - jep instance
      mfac - matrix factory instance
      indexShift - base for array access, either 0 for zero based indexing, or 1 for 1 based indexing

  • Method Details