LinearCombination2

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(that: LinearCombination): LinearCombination

Multiple two linear combinations.

def +(that: LinearCombination)(implicit newOrder: TermOrder): LinearCombination

Addition of two linear combinations.

def +(that: IdealInt): LinearCombination

Add an integer literal to a LinearCombination.

def ++[B >: (IdealInt, Term), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def ++:[B >: (IdealInt, Term), That](that: Traversable[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def ++:[B >: (IdealInt, Term), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def +:[B >: (IdealInt, Term), That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def -(that: LinearCombination)(implicit newOrder: TermOrder): LinearCombination

Subtraction of two linear combinations.

def /(denom: IdealInt): LinearCombination

Divide all coefficients of this linear combination by a constant, rounding downwards

def /:[B](z: B)(op: (B, (IdealInt, Term)) ⇒ B): B

def :+[B >: (IdealInt, Term), That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def :\[B](z: B)(op: ((IdealInt, Term), B) ⇒ B): B

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, (IdealInt, Term)) ⇒ B, combop: (B, B) ⇒ B): B

def andThen[C](k: ((IdealInt, Term)) ⇒ C): PartialFunction[Int, C]

def apply(i: Int): (IdealInt, Term)

def applyOrElse[A1 <: Int, B1 >: (IdealInt, Term)](x: A1, default: (A1) ⇒ B1): B1

final def asInstanceOf[T0]: T0

def assertCtor: Boolean

def canEqual(that: Any): Boolean

def clone(): AnyRef

val coeff0: IdealInt

val coeff1: IdealInt

def coeffIterator: Iterator[IdealInt]

Iterator over all coefficients of the linear combination

def collect[B, That](pf: PartialFunction[(IdealInt, Term), B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def collectFirst[B](pf: PartialFunction[(IdealInt, Term), B]): Option[B]

def combinations(n: Int): Iterator[IndexedSeq[(IdealInt, Term)]]

def companion: GenericCompanion[IndexedSeq]

def compose[A](g: (A) ⇒ Int): (A) ⇒ (IdealInt, Term)

val constant: IdealInt

The constant term of this linear combination (zero if there is no constant term)

def constantDiff(that: LinearCombination): Option[IdealInt]

Return Some(d) if the difference between this and that is only an integer constant d (this = that + d), and None otherwise.

lazy val constants: Set[ConstantTerm]

def constantsIterator: Iterator[ConstantTerm]

def contains[A1 >: (IdealInt, Term)](elem: A1): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def copyToArray[B >: (IdealInt, Term)](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: (IdealInt, Term)](xs: Array[B]): Unit

def copyToArray[B >: (IdealInt, Term)](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: (IdealInt, Term)](dest: Buffer[B]): Unit

def corresponds[B](that: GenSeq[B])(p: ((IdealInt, Term), B) ⇒ Boolean): Boolean

def count(p: ((IdealInt, Term)) ⇒ Boolean): Int

def diff[B >: (IdealInt, Term)](that: GenSeq[B]): IndexedSeq[(IdealInt, Term)]

def distinct: IndexedSeq[(IdealInt, Term)]

def drop(n: Int): IndexedSeq[(IdealInt, Term)]

def dropRight(n: Int): IndexedSeq[(IdealInt, Term)]

def dropWhile(p: ((IdealInt, Term)) ⇒ Boolean): IndexedSeq[(IdealInt, Term)]

def endsWith[B](that: GenSeq[B]): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def exists(p: ((IdealInt, Term)) ⇒ Boolean): Boolean

def filter(p: ((IdealInt, Term)) ⇒ Boolean): IndexedSeq[(IdealInt, Term)]

def filterNot(p: ((IdealInt, Term)) ⇒ Boolean): IndexedSeq[(IdealInt, Term)]

def filterPairs(f: (IdealInt, Term) ⇒ Boolean): LinearCombination

def find(p: ((IdealInt, Term)) ⇒ Boolean): Option[(IdealInt, Term)]

def flatMap[B, That](f: ((IdealInt, Term)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def flatten[B](implicit asTraversable: ((IdealInt, Term)) ⇒ GenTraversableOnce[B]): IndexedSeq[B]

def fold[A1 >: (IdealInt, Term)](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, (IdealInt, Term)) ⇒ B): B

def foldRight[B](z: B)(op: ((IdealInt, Term), B) ⇒ B): B

def forall(p: ((IdealInt, Term)) ⇒ Boolean): Boolean

def foreach[U](f: ((IdealInt, Term)) ⇒ U): Unit

def genericBuilder[B]: Builder[B, IndexedSeq[B]]

def get(t: Term): IdealInt

Determine the coefficient of a certain term in this linear combination, or zero if the term does not occur.

final def getClass(): Class[_]

def getCoeff(i: Int): IdealInt

Method to access the coefficients of the linear combination

def getPair(i: Int): (IdealInt, Term)

def getTerm(i: Int): Term

Method to access the terms of the linear combination

def groupBy[K](f: ((IdealInt, Term)) ⇒ K): Map[K, IndexedSeq[(IdealInt, Term)]]

def grouped(size: Int): Iterator[IndexedSeq[(IdealInt, Term)]]

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: (IdealInt, Term)

def headOption: Option[(IdealInt, Term)]

def indexOf[B >: (IdealInt, Term)](elem: B, from: Int): Int

def indexOf[B >: (IdealInt, Term)](elem: B): Int

def indexOfSlice[B >: (IdealInt, Term)](that: GenSeq[B], from: Int): Int

def indexOfSlice[B >: (IdealInt, Term)](that: GenSeq[B]): Int

def indexWhere(p: ((IdealInt, Term)) ⇒ Boolean, from: Int): Int

def indexWhere(p: ((IdealInt, Term)) ⇒ Boolean): Int

def indices: Range

def init: IndexedSeq[(IdealInt, Term)]

def inits: Iterator[IndexedSeq[(IdealInt, Term)]]

def intersect[B >: (IdealInt, Term)](that: GenSeq[B]): IndexedSeq[(IdealInt, Term)]

def inverseNonConstantTerms(that: LinearCombination): Boolean

Return whether the this and that agree on the non-constant terms, but with inverted sign.

def isConstant: Boolean

Return whether this linear combination is an integer constant

def isDefinedAt(idx: Int): Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isNonZero: Boolean

Return whether the value of this linear combination is never zero

def isPositive: Boolean

A linear combination is called positive if it is not constantly zero and if the leading coefficient is positive

def isPrimitive: Boolean

A linear combination is called primitive if it is not constantly zero and if the coefficients of non-constant terms are coprime.

def isSortedBy(otherOrder: TermOrder): Boolean

final def isTraversableAgain: Boolean

def isZero: Boolean

Return whether the value of this linear combination is constantly zero

def iterator: Iterator[(IdealInt, Term)]

def last: (IdealInt, Term)

def lastCoeff: IdealInt

def lastIndexOf[B >: (IdealInt, Term)](elem: B, end: Int): Int

def lastIndexOf[B >: (IdealInt, Term)](elem: B): Int

def lastIndexOfSlice[B >: (IdealInt, Term)](that: GenSeq[B], end: Int): Int

def lastIndexOfSlice[B >: (IdealInt, Term)](that: GenSeq[B]): Int

def lastIndexWhere(p: ((IdealInt, Term)) ⇒ Boolean, end: Int): Int

def lastIndexWhere(p: ((IdealInt, Term)) ⇒ Boolean): Int

def lastOption: Option[(IdealInt, Term)]

def lastTerm: Term

def lazyPairSeq: IndexedSeq[(IdealInt, Term)]

def lcSize: Int

def leadingCoeff: IdealInt

The leading coefficient of this linear combination

def leadingTerm: Term

The leading monomial of this linear combination

def length: Int

def lengthCompare(len: Int): Int

def lift: (Int) ⇒ Option[(IdealInt, Term)]

def makePositive: LinearCombination

def makePrimitive: LinearCombination

Divide the linear combination by nonConstCoeffGcd such that it becomes primitive (isPrimitive).

def makePrimitiveAndPositive: LinearCombination

Divide the linear combination by nonConstCoeffGcd such that it becomes primitive (isPrimitive), and possibly change the sign so that the linear combination becomes positive (isPositive)

def map[B, That](f: ((IdealInt, Term)) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def max[B >: (IdealInt, Term)](implicit cmp: Ordering[B]): (IdealInt, Term)

def maxBy[B](f: ((IdealInt, Term)) ⇒ B)(implicit cmp: Ordering[B]): (IdealInt, Term)

def min[B >: (IdealInt, Term)](implicit cmp: Ordering[B]): (IdealInt, Term)

def minBy[B](f: ((IdealInt, Term)) ⇒ B)(implicit cmp: Ordering[B]): (IdealInt, Term)

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

def moduloLeadingCoeff: LinearCombination

Reduce all coefficients but the coefficient of the leading term of this with IdealInt.reduceAbs(this.leadingCoeff) and return the remainder.

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[(IdealInt, Term), IndexedSeq[(IdealInt, Term)]]

lazy val nonConstCoeffGcd: IdealInt

The gcd of the coefficients of non-constant terms in the linear combination

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[A1 <: Int, B1 >: (IdealInt, Term)](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

val order: TermOrder

def padTo[B >: (IdealInt, Term), That](len: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def pairIterator: Iterator[(IdealInt, Term)]

lazy val pairSeq: IndexedSeq[(IdealInt, Term)]

def par: ParSeq[(IdealInt, Term)]

def parCombiner: Combiner[(IdealInt, Term), ParSeq[(IdealInt, Term)]]

def partition(p: ((IdealInt, Term)) ⇒ Boolean): (IndexedSeq[(IdealInt, Term)], IndexedSeq[(IdealInt, Term)])

def patch[B >: (IdealInt, Term), That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def permutations: Iterator[IndexedSeq[(IdealInt, Term)]]

def predicates: Set[Predicate]

def prefixLength(p: ((IdealInt, Term)) ⇒ Boolean): Int

def product[B >: (IdealInt, Term)](implicit num: Numeric[B]): B

def reduce[A1 >: (IdealInt, Term)](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: (IdealInt, Term)](op: (B, (IdealInt, Term)) ⇒ B): B

def reduceLeftOption[B >: (IdealInt, Term)](op: (B, (IdealInt, Term)) ⇒ B): Option[B]

def reduceOption[A1 >: (IdealInt, Term)](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: (IdealInt, Term)](op: ((IdealInt, Term), B) ⇒ B): B

def reduceRightOption[B >: (IdealInt, Term)](op: ((IdealInt, Term), B) ⇒ B): Option[B]

def reduceWithLeadingCoeff: LinearCombination

Reduce all coefficients of this with IdealInt.reduceAbs(this.leadingCoeff) and return the quotient.

def repr: IndexedSeq[(IdealInt, Term)]

def reverse: IndexedSeq[(IdealInt, Term)]

def reverseIterator: Iterator[(IdealInt, Term)]

def reverseMap[B, That](f: ((IdealInt, Term)) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def reversed: List[(IdealInt, Term)]

def runWith[U](action: ((IdealInt, Term)) ⇒ U): (Int) ⇒ Boolean

def sameElements[B >: (IdealInt, Term)](that: GenIterable[B]): Boolean

def sameNonConstantTerms(that: LinearCombination): Boolean

Return whether the this and that agree on the non-constant terms.

def scale(coeff: IdealInt): LinearCombination

Multiply all coefficients of this linear combination by a constant

def scaleAndAdd(coeff: IdealInt, const: IdealInt): LinearCombination

Multiply all coefficients of this linear combination by a constant, and add some constant term

def scan[B >: (IdealInt, Term), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def scanLeft[B, That](z: B)(op: (B, (IdealInt, Term)) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def scanRight[B, That](z: B)(op: ((IdealInt, Term), B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def segmentLength(p: ((IdealInt, Term)) ⇒ Boolean, from: Int): Int

def seq: IndexedSeq[(IdealInt, Term)]

def size: Int

def slice(from: Int, until: Int): IndexedSeq[(IdealInt, Term)]

def sliding(size: Int, step: Int): Iterator[IndexedSeq[(IdealInt, Term)]]

def sliding(size: Int): Iterator[IndexedSeq[(IdealInt, Term)]]

def sortBy(newOrder: TermOrder): LinearCombination

Re-sort an object with a new TermOrder.

def sortBy[B](f: ((IdealInt, Term)) ⇒ B)(implicit ord: Ordering[B]): IndexedSeq[(IdealInt, Term)]

def sortWith(lt: ((IdealInt, Term), (IdealInt, Term)) ⇒ Boolean): IndexedSeq[(IdealInt, Term)]

def sorted[B >: (IdealInt, Term)](implicit ord: Ordering[B]): IndexedSeq[(IdealInt, Term)]

def span(p: ((IdealInt, Term)) ⇒ Boolean): (IndexedSeq[(IdealInt, Term)], IndexedSeq[(IdealInt, Term)])

def splitAt(n: Int): (IndexedSeq[(IdealInt, Term)], IndexedSeq[(IdealInt, Term)])

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

def startsWith[B](that: GenSeq[B]): Boolean

def stringPrefix: String

def sum[B >: (IdealInt, Term)](implicit num: Numeric[B]): B

final def synchronized[T0](arg0: ⇒ T0): T0

def tail: IndexedSeq[(IdealInt, Term)]

def tails: Iterator[IndexedSeq[(IdealInt, Term)]]

def take(n: Int): IndexedSeq[(IdealInt, Term)]

def takeRight(n: Int): IndexedSeq[(IdealInt, Term)]

def takeWhile(p: ((IdealInt, Term)) ⇒ Boolean): IndexedSeq[(IdealInt, Term)]

val term0: Term

val term1: Term

def termIterator: Iterator[Term]

Iterator over all terms of the linear combination

lazy val termSeq: IndexedSeq[Term]

def thisCollection: IndexedSeq[(IdealInt, Term)]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (IdealInt, Term), Col[(IdealInt, Term)]]): Col[(IdealInt, Term)]

def toArray[B >: (IdealInt, Term)](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[A1 >: (IdealInt, Term)]: Buffer[A1]

def toCollection(repr: IndexedSeq[(IdealInt, Term)]): IndexedSeq[(IdealInt, Term)]

def toIndexedSeq: IndexedSeq[(IdealInt, Term)]

def toIterable: Iterable[(IdealInt, Term)]

def toIterator: Iterator[(IdealInt, Term)]

def toList: List[(IdealInt, Term)]

def toMap[T, U](implicit ev: <:<[(IdealInt, Term), (T, U)]): Map[T, U]

def toSeq: Seq[(IdealInt, Term)]

def toSet[B >: (IdealInt, Term)]: Set[B]

def toStream: Stream[(IdealInt, Term)]

def toString(): String

def toTraversable: Traversable[(IdealInt, Term)]

def toVector: Vector[(IdealInt, Term)]

def transpose[B](implicit asTraversable: ((IdealInt, Term)) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]

def unary_-: LinearCombination

The negation of a linear combination

def union[B >: (IdealInt, Term), That](that: GenSeq[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

def unzip[A1, A2](implicit asPair: ((IdealInt, Term)) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

def unzip3[A1, A2, A3](implicit asTriple: ((IdealInt, Term)) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])

def updated[B >: (IdealInt, Term), That](index: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], B, That]): That

lazy val variables: Set[VariableTerm]

def variablesIterator: Iterator[VariableTerm]

def view(from: Int, until: Int): SeqView[(IdealInt, Term), IndexedSeq[(IdealInt, Term)]]

def view: SeqView[(IdealInt, Term), IndexedSeq[(IdealInt, Term)]]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def withFilter(p: ((IdealInt, Term)) ⇒ Boolean): FilterMonadic[(IdealInt, Term), IndexedSeq[(IdealInt, Term)]]

def zip[A1 >: (IdealInt, Term), B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], (A1, B), That]): That

def zipAll[B, A1 >: (IdealInt, Term), That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], (A1, B), That]): That

def zipWithIndex[A1 >: (IdealInt, Term), That](implicit bf: CanBuildFrom[IndexedSeq[(IdealInt, Term)], (A1, Int), That]): That

def finalize(): Unit