Type Members
-
class
Elements extends AbstractIterator[A] with BufferedIterator[A] with Serializable
-
-
class
WithFilter extends FilterMonadic[A, Repr]
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
++[B >: LinearCombination, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
++:[B >: LinearCombination, That](that: Traversable[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
++:[B >: LinearCombination, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
+:[B >: LinearCombination, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
-
-
def
:+[B >: LinearCombination, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
-
final
def
==(arg0: Any): Boolean
-
def
addString(b: StringBuilder): StringBuilder
-
def
addString(b: StringBuilder, sep: String): StringBuilder
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
-
def
aggregate[B](z: ⇒ B)(seqop: (B, LinearCombination) ⇒ B, combop: (B, B) ⇒ B): B
-
def
andThen[C](k: (LinearCombination) ⇒ C): PartialFunction[Int, C]
-
-
def
applyOrElse[A1 <: Int, B1 >: LinearCombination](x: A1, default: (A1) ⇒ B1): B1
-
final
def
asInstanceOf[T0]: T0
-
def
canEqual(that: Any): Boolean
-
def
clone(): AnyRef
-
def
collect[B, That](pf: PartialFunction[LinearCombination, B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
collectFirst[B](pf: PartialFunction[LinearCombination, B]): Option[B]
-
def
combinations(n: Int): Iterator[IndexedSeq[LinearCombination]]
-
def
companion: GenericCompanion[IndexedSeq]
-
def
compose[A](g: (A) ⇒ Int): (A) ⇒ LinearCombination
-
lazy val
constants: Set[ConstantTerm]
-
-
def
contains[A1 >: LinearCombination](elem: A1): Boolean
-
def
containsSlice[B](that: GenSeq[B]): Boolean
-
def
copyToArray[B >: LinearCombination](xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray[B >: LinearCombination](xs: Array[B]): Unit
-
def
copyToArray[B >: LinearCombination](xs: Array[B], start: Int): Unit
-
def
copyToBuffer[B >: LinearCombination](dest: Buffer[B]): Unit
-
def
corresponds[B](that: GenSeq[B])(p: (LinearCombination, B) ⇒ Boolean): Boolean
-
-
-
-
-
def
dropRight(n: Int): IndexedSeq[LinearCombination]
-
-
def
endsWith[B](that: GenSeq[B]): Boolean
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
def
exists(p: (LinearCombination) ⇒ Boolean): Boolean
-
-
-
-
def
flatMap[B, That](f: (LinearCombination) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
flatten[B](implicit asTraversable: (LinearCombination) ⇒ GenTraversableOnce[B]): IndexedSeq[B]
-
def
fold[A1 >: LinearCombination](z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft[B](z: B)(op: (B, LinearCombination) ⇒ B): B
-
def
foldRight[B](z: B)(op: (LinearCombination, B) ⇒ B): B
-
def
forall(p: (LinearCombination) ⇒ Boolean): Boolean
-
-
def
genericBuilder[B]: Builder[B, IndexedSeq[B]]
-
final
def
getClass(): Class[_]
-
def
groundAtoms: Set[Atom]
-
-
def
grouped(size: Int): Iterator[IndexedSeq[LinearCombination]]
-
def
hasDefiniteSize: Boolean
-
def
hashCode(): Int
-
-
-
def
implies(that: EquationSet): Boolean
-
def
indexOf[B >: LinearCombination](elem: B, from: Int): Int
-
-
def
indexOfSlice[B >: LinearCombination](that: GenSeq[B], from: Int): Int
-
def
indexOfSlice[B >: LinearCombination](that: GenSeq[B]): Int
-
def
indexWhere(p: (LinearCombination) ⇒ Boolean, from: Int): Int
-
def
indexWhere(p: (LinearCombination) ⇒ Boolean): Int
-
def
indices: Range
-
-
-
-
def
isDefinedAt(idx: Int): Boolean
-
def
isEmpty: Boolean
-
def
isFalse: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isSortedBy(otherOrder: TermOrder): Boolean
-
final
def
isTraversableAgain: Boolean
-
def
isTrue: Boolean
-
-
-
def
lastIndexOf[B >: LinearCombination](elem: B, end: Int): Int
-
def
lastIndexOf[B >: LinearCombination](elem: B): Int
-
def
lastIndexOfSlice[B >: LinearCombination](that: GenSeq[B], end: Int): Int
-
def
lastIndexOfSlice[B >: LinearCombination](that: GenSeq[B]): Int
-
def
lastIndexWhere(p: (LinearCombination) ⇒ Boolean, end: Int): Int
-
def
lastIndexWhere(p: (LinearCombination) ⇒ Boolean): Int
-
-
lazy val
leadingTermSet: Set[Term]
-
def
length: Int
-
def
lengthCompare(len: Int): Int
-
-
-
def
map[B, That](f: (LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
-
-
-
-
def
mkString: String
-
def
mkString(sep: String): String
-
def
mkString(start: String, sep: String, end: String): String
-
final
def
ne(arg0: AnyRef): Boolean
-
-
-
def
nonEmpty: Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
orElse[A1 <: Int, B1 >: LinearCombination](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
-
-
def
padTo[B >: LinearCombination, That](len: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
-
-
-
def
patch[B >: LinearCombination, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
permutations: Iterator[IndexedSeq[LinearCombination]]
-
def
predicates: Set[Predicate]
-
def
prefixLength(p: (LinearCombination) ⇒ Boolean): Int
-
def
product[B >: LinearCombination](implicit num: Numeric[B]): B
-
-
def
reduce[A1 >: LinearCombination](op: (A1, A1) ⇒ A1): A1
-
-
-
def
reduceOption[A1 >: LinearCombination](op: (A1, A1) ⇒ A1): Option[A1]
-
-
-
val
relationString: String
-
-
-
-
def
reverseMap[B, That](f: (LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
-
def
runWith[U](action: (LinearCombination) ⇒ U): (Int) ⇒ Boolean
-
def
sameElements[B >: LinearCombination](that: GenIterable[B]): Boolean
-
def
scan[B >: LinearCombination, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
scanLeft[B, That](z: B)(op: (B, LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
scanRight[B, That](z: B)(op: (LinearCombination, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
segmentLength(p: (LinearCombination) ⇒ Boolean, from: Int): Int
-
-
def
size: Int
-
def
slice(from: Int, until: Int): IndexedSeq[LinearCombination]
-
def
sliding(size: Int, step: Int): Iterator[IndexedSeq[LinearCombination]]
-
def
sliding(size: Int): Iterator[IndexedSeq[LinearCombination]]
-
-
-
-
-
-
-
def
startsWith[B](that: GenSeq[B], offset: Int): Boolean
-
def
startsWith[B](that: GenSeq[B]): Boolean
-
def
stringPrefix: String
-
def
sum[B >: LinearCombination](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
-
-
def
takeRight(n: Int): IndexedSeq[LinearCombination]
-
-
-
-
def
toArray[B >: LinearCombination](implicit arg0: ClassTag[B]): Array[B]
-
-
-
-
-
-
-
def
toMap[T, U](implicit ev: <:<[LinearCombination, (T, U)]): Map[T, U]
-
-
-
def
toSet: Set[LinearCombination] { ... /* 2 definitions in type refinement */ }
-
-
-
def
toString(): String
-
-
-
def
transpose[B](implicit asTraversable: (LinearCombination) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
-
def
union[B >: LinearCombination, That](that: GenSeq[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
def
unzip[A1, A2](implicit asPair: (LinearCombination) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
-
def
unzip3[A1, A2, A3](implicit asTriple: (LinearCombination) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
-
-
-
def
updated[B >: LinearCombination, That](index: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
-
lazy val
variables: Set[VariableTerm]
-
-
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
wait(): Unit
-
-
def
zip[A1 >: LinearCombination, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, B), That]): That
-
def
zipAll[B, A1 >: LinearCombination, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, B), That]): That
-
def
zipWithIndex[A1 >: LinearCombination, That](implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, Int), That]): That
Deprecated Value Members
-
def
finalize(): Unit
Inherited from Equals
Inherited from HasNewBuilder[LinearCombination, IndexedSeq[ap.terfor.linearcombination.LinearCombination] @scala.annotation.unchecked.uncheckedVariance]
Inherited from AnyRef
Inherited from Any
The class for representing conjunctions of equations, i.e., of systems of equations. Systems of equations are always implicitly canonised and reduced by means of row operations, i.e., it is ensured that the leading terms of two equations are always distinct, and that no equation can be made smaller in the used
TermOrder
by adding multiples of other equations. This is not a complete method for deciding the satisfiability of a system, it is also necessary to perform column operations. Column operations are not applied implicitly, however.