Class ScalarTurboEvaluator1

java.lang.Object
com.github.gbenroscience.parser.turbo.tools.ScalarTurboEvaluator1
All Implemented Interfaces:
Savable, TurboExpressionEvaluator, Serializable
Direct Known Subclasses:
AndroidCapableMatrixTurboEvaluator, BulkTurboEvaluator, MatrixTurboEvaluator
public class ScalarTurboEvaluator1 extends Object implements TurboExpressionEvaluator, Savable
Turbo compiler optimized for PURE SCALAR expressions. Uses an array based technique to pass variables to the evaluator
Author:
GBEMIRO
See Also:

  • Field Details

    • willFoldConstants

      protected boolean willFoldConstants

    • slots

      protected final int[] slots

    • registry

      protected MathExpression.VariableRegistry registry

    • SCALAR_GATEKEEPER_HANDLE

      public static final MethodHandle SCALAR_GATEKEEPER_HANDLE

    • VECTOR_GATEKEEPER_HANDLE

      public static final MethodHandle VECTOR_GATEKEEPER_HANDLE

    • VECTOR_2_GATEKEEPER_HANDLE

      public static final MethodHandle VECTOR_2_GATEKEEPER_HANDLE

    • postfix

      protected MathExpression.Token[] postfix

    • errorLog

      protected ErrorLog errorLog

  • Constructor Details

    • ScalarTurboEvaluator1

      public ScalarTurboEvaluator1(MathExpression me)
      Parameters:
      me -

  • Method Details

    • getNextResult

      public MathExpression.EvalResult getNextResult()

    • setWillFoldConstants

      public void setWillFoldConstants(boolean willFoldConstants)

    • isWillFoldConstants

      public boolean isWillFoldConstants()

    • invokeRegistryMethod

      public static MathExpression.EvalResult invokeRegistryMethod(int methodId, double[] argsValues)
      Hardened production bridge. Zero allocation for arity invalid input: '<'= 8. Safely scales for any arity without crashing.

    • compile

      public FastCompositeExpression compile() throws Throwable
      ////////////////////////////////////////UPDATE STARTS////////////////////////////////////////////////////////////////////////////////
      Specified by:
      compile in interface TurboExpressionEvaluator
      Returns:
      A FastCompositeExpression ready for evaluation
      Throws:
      Throwable - if compilation fails

    • compileScalar

      protected MethodHandle compileScalar(MathExpression.Token[] postfix) throws Throwable
      Throws:
      Throwable

    • combineArgs

      public static MethodHandle combineArgs(List<MethodHandle> argumentHandles) throws Exception
      Combines multiple handles of type (double[])double into a single handle of type (double[])double[].
      Parameters:
      argumentHandles -
      Throws:
      Exception

    • invokeComplexStats1

      public static Object invokeComplexStats1(MethodHandle gatekeeper, String name, Object[] parts, double[] vars) throws Throwable
      Throws:
      Throwable

    • invokeComplexStats

      public static Object invokeComplexStats(MethodHandle gatekeeper, String name, Object[] parts, double[] vars) throws Throwable
      Throws:
      Throwable

    • invokeCustomFunction

      public static double invokeCustomFunction(String funcName, double[] argsValues)
      Safe runtime execution bridge for custom FunctionManager functions.
      Parameters:
      funcName -
      argsValues -
      Returns:

    • createConstantHandle

      public static MethodHandle createConstantHandle(double value)

    • unwrapToDouble

      public static double unwrapToDouble(Object obj)

    • executeTurboIntegral

      public static double executeTurboIntegral(Function f, MethodHandle handle, double lower, double upper, int iterations, String[] vars, int[] slots) throws Throwable
      Throws:
      Throwable

    • scalarStatsGatekeeper

      public static double scalarStatsGatekeeper(String method, double[] data)

    • vectorStatsGatekeeper

      public static double[] vectorStatsGatekeeper(String method, double[] data)

    • vectorNonStatsGatekeeper

      public static double[] vectorNonStatsGatekeeper(String method, String funcHandle)

    • executeTurboRoot

      public static double executeTurboRoot(MethodHandle baseHandle, MethodHandle derivHandle, int xSlot, double lower, double upper, int iterations)
      Execution bridge for the TurboRootFinder. This is invoked by the compiled MethodHandle chain.
      Parameters:
      baseHandle -
      derivHandle -
      xSlot -
      lower -
      upper -
      iterations -
      Returns:

    • executeQuadraticRoot

      public static double[] executeQuadraticRoot(String funcHandle)

    • executeTartagliaRoot

      public static double[] executeTartagliaRoot(String funcHandle)

    • getOptimizedPowerHandle

      public static MethodHandle getOptimizedPowerHandle(double n) throws Throwable
      Throws:
      Throwable

    • getUnaryFunctionHandle

      protected static MethodHandle getUnaryFunctionHandle(String name) throws Throwable
      Get unary function handle (arity 1). Supports: - Trigonometric: sin, cos, tan, asin, acos, atan (with DRG variants) - Logarithmic: log, ln, log10 - Power/Root: sqrt, cbrt - Rounding: floor, ceil, abs - Other: exp, fact
      Throws:
      Throwable

    • sec

      public static double sec(double x)

    • csc

      public static double csc(double x)

    • cot

      public static double cot(double x)

    • asec

      public static double asec(double x)

    • acsc

      public static double acsc(double x)

    • acot

      public static double acot(double x)

    • getDoubleFromArray

      public static double getDoubleFromArray(double[] array, int index)

    • gradToRad

      public static double gradToRad(double grads)

    • add

      public static double add(double a, double b)
      Inlined addition: a + b

    • subtract

      public static double subtract(double a, double b)
      Inlined subtraction: a - b

    • multiply

      public static double multiply(double a, double b)
      Inlined multiplication: a * b

    • divide

      public static double divide(double a, double b)
      Inlined division: a / b with zero-check

    • modulo

      public static double modulo(double a, double b)
      Inlined modulo: a % b

    • square

      public static double square(double x)

    • cube

      public static double cube(double x)

    • quad

      public static double quad(double x)

    • executeTurboODE

      public static double executeTurboODE(MethodHandle dy_dt, int tSlot, int ySlot, int frameSize, double t0, double y0, double tEnd, double initialStep, DifferentialEquations.ODESolverMethod method) throws Throwable
      Throws:
      Throwable