Package jline.api.sym

Interface SymEngine

All Known Implementing Classes:
SageRestEngine
public interface SymEngine
Computer algebra operations LINE needs, as seen by the JAR.

Java has no computer algebra system, so every operation here is delegated to an external engine; SageRestEngine is the SageMath implementation and is resolved by SymEngines. Expressions cross the interface as plain ASCII infix strings, e.g. "2*x1 - 3*x2", which is the format SolverCTMC.symbolicGeneratorResult.getSymbolicEntry already produces.

Expression strings are not comparable across codebases: the symbol numbering x1..xE follows event enumeration order, and printed normal forms depend on the engine version. Compare by substituting values with eval(java.util.List<java.lang.String>, java.util.Map<java.lang.String, java.lang.Double>) and comparing numbers.

Copyright (c) 2012-2026, Imperial College London All rights reserved.

  • Method Details

    • name

      String name()
      Name of the backing engine, e.g. "sage".

    • isAvailable

      boolean isAvailable()
      True if the engine answers a health probe.

    • solveCTMC

      SymEngine.CTMCSolution solveCTMC(String[][] Q, List<String> symbols) throws IOException
      Symbolic stationary distribution of a CTMC, pi Q = 0 with sum(pi) = 1.
      Parameters:
      Q - generator entries as expression strings, row major
      symbols - the symbols appearing in Q, e.g. x1..xE
      Returns:
      the solution, with pi also split over a common denominator
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • ctmcSensitivity

      SymEngine.Sensitivity ctmcSensitivity(String[][] Q, List<String> symbols, String theta, List<String> reward) throws IOException
      Exact parametric sensitivity of a steady-state reward.
      Parameters:
      Q - generator entries as expression strings, row major
      symbols - the symbols appearing in Q
      theta - the symbol to differentiate with respect to
      reward - reward rate per state, or null for the distribution alone
      Returns:
      the sensitivity of the distribution and, if a reward is given, of its mean
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • ctmcMeasures

      SymEngine.CTMCMeasures ctmcMeasures(String[][] Q, List<String> symbols, String[][] weights, List<String> names, List<SymEngine.RatioSpec> ratios) throws IOException
      Stationary distribution and a set of weighted sums of it.

      Every mean SolverCTMC reports is a NUMERIC linear functional of pi, so the caller builds one weight vector per measure with no algebra at all and this one round trip returns each w . pi as a rational function: a throughput is pi . depRates, a queue length is pi . stateSpaceAggr, a marginal probability is pi . indicator and a mean reward is pi . r.

      Parameters:
      Q - generator entries as expression strings, row major
      symbols - the symbols appearing in Q
      weights - one row per measure, each of length Q.length; entries are parsed in the same field as Q, so an expression is admissible and not only a number
      names - a name per weight row, or null for w0, w1, ...
      ratios - ratios of two measures, or null for none
      Returns:
      the distribution, the measures and the ratios
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • ctmcPassage

      SymEngine.Passage ctmcPassage(String[][] S, String[] s0, String[] alpha, String atom, List<String> symbols, String svar, List<String> want, int nmax) throws IOException
      First passage time into a target set: the transform and the moments.

      With A the complement of the target, S = Q(A,A) the sub-generator, s0 = -S*1 the exit vector and alpha the initial law restricted to A, following Harrison and Knottenbelt (2002),

        L(s) = alpha (sI - S)^-1 s0 + atom        Eqs. 1-2
  (-S) M(n) = n M(n-1),  M(0) = 1           Eq. 3

      The MOMENTS come from the recursion, not from differentiating L: it carries no transform symbol, stays in the same fraction field and is nmax right solves against one matrix. Differentiating instead would leave the fraction field, and the evaluation at s = 0 can hit 0/0 where a factor of s failed to cancel.

      Parameters:
      S - the sub-generator on the non-target states, row major
      s0 - the exit vector -S*1
      alpha - the initial law restricted to the non-target states
      atom - the initial mass already inside the target set
      symbols - the rate symbols appearing in S
      svar - the transform symbol; adjoined to the field only when a transform is asked for, and required to differ from every rate symbol
      want - any of lst, lstall, moments, momall
      nmax - highest moment order, at least 1
      Returns:
      the requested items
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • simplify

      List<String> simplify(List<String> exprs, String form) throws IOException
      Rewrites expressions into a normal form.
      Parameters:
      exprs - the expressions
      form - one of simplify, factor, together, cancel, expand, latex
      Returns:
      the rewritten expressions, in the input order
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • diff

      List<String> diff(List<String> exprs, String variable, int order) throws IOException
      Differentiates expressions.
      Parameters:
      exprs - the expressions
      variable - the differentiation variable
      order - the order of the derivative, at least 1
      Returns:
      the derivatives, in the input order
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • eval

      double[] eval(List<String> exprs, Map<String,Double> assignment) throws IOException
      Substitutes values for symbols and evaluates.
      Parameters:
      exprs - the expressions
      assignment - value of each symbol
      Returns:
      the numeric values, NaN where a free symbol remains
      Throws:
      IOException - if the engine is unreachable or rejects the request

    • fluidODEs

      SymEngine.FluidODEs fluidODEs(List<String> rhs, List<String> vars, List<String> want) throws IOException
      Jacobian, LaTeX form and equilibria of a fluid vector field.
      Parameters:
      rhs - the right hand side of dx/dt, one expression per state variable
      vars - the state variable names
      want - any of jacobian, latex, equilibria
      Returns:
      the requested items
      Throws:
      IOException - if the engine is unreachable or rejects the request