Packages

class IndexEquationSolver extends ExpressionEquationIndexifier

Seek an approximately stable distribution for equations given in terms of indices, hence solving the equations (approximately). Here stable distribution is under the iteration to solve equations viewing them as fixed points. A few quantitites related to the solutions, or the equations themselves, are also computed.

Linear Supertypes
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IndexEquationSolver
  2. ExpressionEquationIndexifier
  3. AnyRef
  4. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new IndexEquationSolver(initMap: Map[Expression, Double], equationVec: Vector[Equation], params: (Coeff[_]) => Option[Double], maxRatio: Double, resolution: Double, exponent: Double, decay: Double, maxTime: Option[Long], previousMap: Option[Map[Expression, Double]])

    initMap

    initial values of some expressions

    params

    values of coefficients in the equations

    maxRatio

    bound on ratio of stabilization

    resolution

    additive scale for stabilization and some auxiliary quantities

    exponent

    the next step is stabilized using geometric means, weighted by the exponent

    decay

    decay of the exponent, to allow steps to be damped progressively more

    maxTime

    time in milliseconds for timing out stabilizations

    previousMap

    an optional previous map to initialize

Value Members

  1. def bigRatio(v: Vector[Double], w: Vector[Double], bound: Double = maxRatio): Vector[((Double, Double), Int)]
  2. lazy val constantEquations: Set[Int]
  3. def equalSupport(v: Vector[Double], w: Vector[Double]): Boolean
  4. def equationGradients(v: ParSeq[Double]): ParVector[ParVector[Double]]
  5. val equationVec: Vector[Equation]
  6. lazy val finalMap: Map[Expression, Double]

    values of expressions in an approximately stable solution to the equation

    values of expressions in an approximately stable solution to the equation

    returns

    map of approximate solution values

  7. lazy val finalVec: ParVector[Double]

    vector of values (at indices) in an approximately stable solution to the equation

    vector of values (at indices) in an approximately stable solution to the equation

    returns

    vector of approximate solution values

  8. def getProd(exp: Expression): ProductIndexExpression
  9. def gradient(index: Int, decay: Double = 1.0, depth: Int): Vector[(Int, Double)]
  10. def gradientNextStep(predecessor: Vector[(Int, Double)]): Vector[(Int, Double)]
  11. def gradientStep(index: Int): Vector[(Int, Double)]
  12. val gradientTerms: Vector[ArrayBuffer[Vector[(Int, Double)]]]
  13. def gradientUptoMemo(j: Int, depth: Int): Vector[Vector[(Int, Double)]]
  14. lazy val indexMap: Map[Expression, Int]
  15. lazy val initPar: ParMap[Expression, Double]
  16. lazy val initTermIndices: Vector[Int]
  17. lazy val initTypIndices: Vector[Int]
  18. lazy val initVector: ParVector[Double]
  19. def mapToIndexMap[V](m: Map[Expression, V]): Map[Int, V]
  20. def nextTraceSet(current: Set[Set[Int]], relativeTo: Set[Int]): Set[Set[Int]]
  21. def nextTraceVector(current: Vector[Vector[Int]]): Vector[Vector[Int]]
  22. def nextVec(v: ParVector[Double], exponent: Double): ParVector[Double]
  23. def normalizedBounded(v: Vector[Double], w: Vector[Double], report: Boolean = false): Boolean
  24. val numVars: Int
  25. def orthonormalGradients(v: ParSeq[Double], cutoff: Double = 0.0): ParVector[ParVector[Double]]
  26. def proofData(typ: Typ[Term]): Vector[(Int, Equation)]
  27. lazy val randomVarIndices: ParVector[Vector[Int]]
  28. def ratioBounded(v: Vector[Double], w: Vector[Double], bound: Double = maxRatio): Boolean
  29. final def recTraceSet(current: Set[Set[Int]], depth: Int, relativeTo: Set[Int], accum: Set[Set[Int]]): Set[Set[Int]]
    Definition Classes
    ExpressionEquationIndexifier
    Annotations
    @tailrec()
  30. def restrict(v: Vector[Double], indices: Vector[Int]): Vector[Double]
  31. lazy val rhsExprs: Vector[SumIndexExpression]
  32. lazy val rhsExprsPar: ParVector[SumIndexExpression]
  33. def rhsInvolves(js: Set[Int]): Set[Int]
  34. def simpleNextVec(v: ParVector[Double]): ParVector[Double]
  35. def simplify(exp: Expression): SumIndexExpression
  36. lazy val size: Int
  37. final def stableSupportVec(initVec: ParVector[Double], maxTime: Option[Long], steps: Long): ParVector[Double]
    Annotations
    @tailrec()
  38. final def stableVec(initVec: ParVector[Double], exponent: Double = 0.5, decay: Double, maxTime: Option[Long], steps: Long): ParVector[Double]
    Annotations
    @tailrec()
  39. lazy val termIndexVec: Vector[(Term, Int)]
  40. lazy val termIndices: Vector[Int]
  41. lazy val thmPfIndices: Map[Int, Vector[Int]]
  42. lazy val totalProbEquations: ParVector[ParVector[Double]]
  43. def traceIndices(j: Int, depth: Int): Vector[Int]
  44. def traceSet(elem: Expression, depth: Int, relativeTo: Set[Int]): Set[Set[Int]]
  45. def track(exp: Expression): Option[(Int, Double, SumIndexExpression, Double, Vector[Double])]
  46. def trackOutput(exp: Expression): String
  47. lazy val typIndexVec: Vector[(Typ[Term], Int)]
  48. lazy val typIndices: Vector[Int]
  49. lazy val varVec: Vector[Expression]