Packages

object EvolverEquations

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. EvolverEquations
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def appendContext(ctxs: Vector[Vector[Term]], context: Vector[Term]): Vector[Vector[Term]]

    appends a context avoiding duplication up to change of variables

  2. def contextsOfTerm(term: Term): Vector[Vector[Term]]

    all the contexts in which a term lies, including the empty one.

  3. def equalContexts(ctx1: Vector[Term], ctx2: Vector[Term]): Boolean

    returns whether contexts are equal up to change of variables

  4. def klDiff[F](p: F, q: F)(implicit arg0: Field[F], arg1: Trig[F]): F
  5. def projectContext(fromCtx: Vector[Term], toCtx: Vector[Term])(term: Term): Option[Term]

    optionally project a term in the first context onto the second context

  6. def projectSomeContext(toCtxs: Vector[Vector[Term]])(term: Term, fromCtx: Vector[Term]): Option[(Term, Vector[Term])]

    optionally project a given term with a given context to one of a vector of target contexts.

    optionally project a given term with a given context to one of a vector of target contexts.

    returns

    optional pair (term in new context, new context)

  7. def sum[F](seq: Iterable[F])(implicit field: Field[F]): F

    sum of elements in a field

  8. def termInSomeContext(term: Term, contexts: Vector[Vector[Term]], accum: Option[(Term, Vector[Term])] = None): Option[(Term, Vector[Term])]

    import term into some context in a vector of contexts if it matches.

    import term into some context in a vector of contexts if it matches.

    Annotations
    @tailrec()
  9. def termOptContext(term: Term, context: Vector[Term]): Option[Term]

    if term is of the form x :-> y, it is imported into a context of the form x' :-> _ as x' :-> y' if x and x' have the same type; this should be done recursively as in a context x:-> w :-> _, the type of w may depend on x.

  10. def termsInContext(terms: Set[Term], context: Vector[Term]): Set[Term]

    terms of the form x :-> y or x ~>: y imported into a context of the form x' :-> _ as x' :-> y' if x and x' have the same type; this should be done recursively as in a context x:-> w :-> _, the type of w may depend on x.

  11. def typsInContext(typs: Set[Typ[Term]], context: Vector[Term]): Set[Typ[Term]]

    typs of the form x ~>: y imported into a context of the form x' :-> _ as x' ~>: y' if x and x' have the same type; this should be done recursively as in a context x:-> w :-> _, the type of w may depend on x.