AbstractAST

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<IExpr>
  - - org.matheclipse.core.expression.AbstractAST

All Implemented Interfaces:

edu.jas.structure.AbelianGroupElem<IExpr>, edu.jas.structure.Element<IExpr>, edu.jas.structure.GcdRingElem<IExpr>, edu.jas.structure.MonoidElem<IExpr>, edu.jas.structure.RingElem<IExpr>, java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<IExpr>, java.lang.Iterable<IExpr>, java.util.Collection<IExpr>, java.util.List<IExpr>, org.apache.commons.math4.FieldElement<IExpr>, IAST, IExpr

Direct Known Subclasses:

AST0, HMArrayList, NILPointer
```
public abstract class AbstractAST
extends java.util.AbstractList<IExpr>
implements IAST
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class AbstractAST.ASTIterator
- Nested classes/interfaces inherited from interface org.matheclipse.core.interfaces.IAST
  IAST.PROPERTY

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AbstractAST.ASTIterator`

Field Summary

Fields
Modifier and Type Field and Description

protected int fEvalFlags
Flags for controlling evaluation and left-hand-side pattern-matching expressions

protected int hashValue
- Fields inherited from class java.util.AbstractList
  modCount
- Fields inherited from interface org.matheclipse.core.interfaces.IAST
  CONTAINS_DEFAULT_PATTERN, CONTAINS_NO_DEFAULT_PATTERN_MASK, CONTAINS_NO_PATTERN, CONTAINS_PATTERN, CONTAINS_PATTERN_EXPR, CONTAINS_PATTERN_SEQUENCE, IS_ALL_EXPANDED, IS_DECOMPOSED_PARTIAL_FRACTION, IS_EXPANDED, IS_FLAT_ORDERLESS_EVALED, IS_FLATTENED, IS_FLATTENED_OR_SORTED_MASK, IS_LISTABLE_THREADED, IS_MATRIX, IS_MATRIX_OR_VECTOR, IS_SORTED, IS_VECTOR, NO_FLAG
- Fields inherited from interface org.matheclipse.core.interfaces.IExpr
  ASTID, BLANKID, COMPLEXID, DOUBLECOMPLEXID, DOUBLEID, FRACTIONID, INTEGERID, METHODSYMBOLID, PATTERNID, STRINGID, SYMBOLID

Fields
Modifier and Type	Field and Description
`protected int`	`fEvalFlags` Flags for controlling evaluation and left-hand-side pattern-matching expressions
`protected int`	`hashValue`

Constructor Summary

Constructors
Constructor and Description

AbstractAST()

Constructors
Constructor and Description
`AbstractAST()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`IExpr`	`$div(IExpr that)` Operator overloading for Scala operator `/`.
`IExpr`	`$minus(IExpr that)` Operator overloading for Scala operator `/`.
`IExpr`	`$plus(IExpr that)` Operator overloading for Scala operator `+`.
`IExpr`	`$times(IExpr that)` Operator overloading for Scala operator `*`.
`IExpr`	`$up(IExpr that)` Operator overloading for Scala operator `^`.
`IExpr`	`abs()` Absolute value of this.
`<T> T`	`accept(IVisitor<T> visitor)` Accept a visitor with return type T
`boolean`	`accept(IVisitorBoolean visitor)` Accept a visitor with return type `boolean`
`int`	`accept(IVisitorInt visitor)` Accept a visitor with return type `int`
`long`	`accept(IVisitorLong visitor)` Accept a visitor with return type `long`
`IAST`	`addAtClone(int position, IExpr expr)` Create a shallow copy of this `IAST` instance (the elements themselves are not copied) and add the `expr` at the given `position`.
`void`	`addEvalFlags(int i)` Add an evaluation flag to the existing ones.
`IExpr`	`and(IExpr that)`
`IAST`	`appendClone(IExpr expr)` Append an expression to this list.
`IExpr`	`apply(IExpr... leaves)`
`IAST`	`apply(IExpr head)` Apply the given head to this expression (i.e. create a list clone and replace the old head with the given one)
`IAST`	`apply(IExpr head, int start)` Apply the given head to this expression (i.e. create a sublist clone starting from index start and replacing the old head with the given one)
`IAST`	`apply(IExpr head, int start, int end)` Apply the given head to this expression (i.e. create a sublist clone from index start to end, and replacing the old head with the given one)
`IExpr`	`apply(java.util.List<? extends IExpr> leaves)`
`ASTRange`	`args()` Get the range of elements [1..ast.size()[.
`java.lang.Object`	`asType(java.lang.Class<?> clazz)`
`void`	`clearHashCache()` Set the cached hash value to zero.
`IAST`	`clone()` Returns a shallow copy of this `IAST` instance (the elements themselves are not cloned).
`int`	`compareTo(IExpr rhsExpr)` Compares this expression with the specified expression for canonical order.
`boolean`	`contains(java.lang.Object object)`
`IAST`	`copy()` Returns a shallow copy of this `IAST` instance (the elements themselves are not copied).
`IAST`	`copyFrom(int index)` Create a copy of this `AST`, which contains the same head and all elements from to the given `position` (inclusive).
`IAST`	`copyHead()` Create a copy of this `AST`, which only contains the head element of the list (i.e. the element with index 0).
`IAST`	`copyUntil(int index)` Create a copy of this `AST`, which contains the same head and all elements up to the given `position` (exclusive).
`IAST`	`copyUntil(int intialCapacity, int index)` Create a copy of this `AST`, which contains the same head and all elements up to the given `position` (exclusive).
`IExpr`	`dec()` Returns an `IExpr` whose value is `(this - 1)`.
`IExpr`	`divide(IExpr that)` Returns an `IExpr` whose value is `(this / that)`.
`IExpr[]`	`egcd(IExpr b)` Extended greatest common divisor.
`boolean`	`equals(java.lang.Object obj)` Test if this is equal to b.
`boolean`	`equalsAt(int position, IExpr expr)` Calls `get(position).equals(expr)`.
`boolean`	`equalsFromPosition(int from0, IAST f1, int from1)`
`org.apache.commons.math4.complex.Complex`	`evalComplex()` Evaluate the expression to a `INumber` value.
`double`	`evalDouble()` Evaluate the expression to a Java `double` value.
`INumber`	`evalNumber()` Evaluate the expression to a `INumber` value.
`ISignedNumber`	`evalSignedNumber()` Evaluate the expression to a `ISignedNumber` value.
`IExpr`	`evaluate(EvalEngine engine)` Evaluate an expression
`edu.jas.structure.ElemFactory<IExpr>`	`factory()` Get the corresponding element factory.
`IAST[]`	`filter(java.util.function.Function<IExpr,IExpr> function)` Select all elements by applying the `function` to each argument in this `AST` and append the result elements for which the function returns non-null elements to the `0th element` of the result array, or otherwise append it to the `1st element` of the result array.
`IAST`	`filter(IAST filterAST, IAST restAST, java.util.function.Function<IExpr,IExpr> function)` Select all elements by applying the `function` to each argument in this `AST` and append the result elements for which the `function` returns non-null elements to the `filterAST`, or otherwise append the argument to the `restAST`.
`IAST`	`filter(IAST filterAST, IAST restAST, java.util.function.Predicate<? super IExpr> predicate)` Select all elements by applying the `predicate` to each argument in this `AST` and append the elements which satisfy the `predicate` to the `filterAST`, or otherwise append it to the `restAST`.
`IAST`	`filter(IAST filterAST, IExpr expr)` Select all elements by applying the `Predicates.isTrue(expr)` predicate to each argument in this `AST` and append the elements which satisfy the `Predicates.isTrue(expr)` predicate to the `filterAST`.
`IAST`	`filter(IAST filterAST, java.util.function.Predicate<? super IExpr> predicate)` Select all elements by applying the `predicate` to each argument in this `AST` and append the arguments which satisfy the predicate to the `filterAST`.
`IAST`	`filter(IAST filterAST, java.util.function.Predicate<? super IExpr> predicate, int maxMatches)` Select all elements by applying the `predicate` to each argument in this `AST` and append up to `maxMatches` arguments which satisfy the predicate to the `filterAST`.
`IAST[]`	`filter(java.util.function.Predicate<? super IExpr> predicate)` Select all elements by applying the `predicate` to each argument in this `AST` and append the arguments which satisfy the predicate to the `0th element` of the result array, or otherwise append it to the `1st element` of the result array.
`int`	`findFirstEquals(IExpr expr)` Find the first argument position, which equals `expr`.
`void`	`forEach(java.util.function.Consumer<? super IExpr> action)` Iterate over all elements from index `1` to `size()-1` and call the method `Consumer.accept()` for these elements.
`java.lang.String`	`fullFormString()` Return the `FullForm()` of this expression
`IExpr`	`gcd(IExpr that)` Greatest common divisor.
`IExpr`	`get(int location)`
`IAST`	`getAST(int index)` Casts an `IExpr` at position `index` to an `IAST`.
`IExpr`	`getAt(int index)` Get the element at the specified `index` if this object is of type `IAST`.
`int`	`getEvalFlags()` Get the evaluation flags for this list.
`int`	`getHashCache()` Get the cached hash value.
`IInteger`	`getInt(int index)` Casts an `IExpr` at position `index` to an `IInteger`.
`IAST`	`getList(int index)` Casts an `IExpr` which is a list at position `index` to an `IAST`.
`INumber`	`getNumber(int index)` Casts an `IExpr` at position `index` to an `INumber`.
`IExpr`	`getOneIdentity(IExpr defaultValue)` Get the argument at index 1, if the `size() == 2` or the complete ast if the `size() > 2` (useful for ASTs with attribute `OneIdentity` for example for `Plus[]` you can call `getOneIdentity(F.C0)` or for `Times[]`) you can call `getOneIdentity(F.C1)`.
`IExpr`	`getPart(int... positions)` Returns the element at the specified positions in the nested ASTs.
`IExpr`	`getPart(java.util.List<java.lang.Integer> positions)` Returns the element at the specified positions in the nested ASTs.
`int`	`hashCode()` Hashcode of this Element.
`int`	`hierarchy()` A unique integer ID for the implementation of this expression
`IExpr`	`inc()` Returns an `IExpr` whose value is `(this + 1)`.
`int`	`indexOf(java.lang.Object object)`
`java.lang.String`	`internalFormString(boolean symbolsAsFactoryMethod, int depth)` Return the internal Java form of this expression.
`java.lang.String`	`internalJavaString(boolean symbolsAsFactoryMethod, int depth, boolean useOperators)` Return the internal Java form of this expression.
`java.lang.String`	`internalScalaString(boolean symbolsAsFactoryMethod, int depth)` Return the internal Scala form of this expression.
`IExpr`	`inverse()` Returns the multiplicative inverse of this object.
`boolean`	`isAllExpanded()` Test if this expression and all subexpressions are already expanded i.e.
`boolean`	`isAnd()` Test if this expression is the function `And[<arg>,...]`
`boolean`	`isArcCos()` Test if this expression is the function `ArcCos[<arg>]`
`boolean`	`isArcCosh()` Test if this expression is the function `ArcCosh[<arg>]`
`boolean`	`isArcSin()` Test if this expression is the function `ArcSin[<arg>]`
`boolean`	`isArcSinh()` Test if this expression is the function `ArcSinh[<arg>]`
`boolean`	`isArcTan()` Test if this expression is the function `ArcTan[<arg>]`
`boolean`	`isArcTanh()` Test if this expression is the function `ArcTanh[<arg>]`
`boolean`	`isAST()` Test if this expression is an AST list, which contains a header element (i.e. the function name) at index position `0` and some optional argument elements at the index positions `1..n`.
`boolean`	`isAST(IExpr header)` Test if this expression is an AST list, which contains the given header element at index position `0` and some optional argument elements at the index positions `1..`
`boolean`	`isAST(IExpr header, int length)` Test if this expression is an AST list, which contains the given header element at index position `0` and optional argument elements at the index positions `1..`
`boolean`	`isAST(IExpr header, int length, IExpr... args)` Test if this expression is an AST list, which contains the given header element at index position `0` and optional argument elements at the index positions `1..`
`boolean`	`isAST(IExpr header, int minLength, int maxLength)` Test if this expression is an AST list, which contains the given header element at index position `0` and optional argument elements at the index positions `1..`
`boolean`	`isAST(java.lang.String symbol)` Test if this expression is an AST list, where the string representation of the header element at index position `0` equals the given `symbol` and some optional argument elements at the index positions `1..`
`boolean`	`isAST(java.lang.String symbol, int length)` Test if this expression is an AST list, where the string representation of the header element at index position `0` equals the given `symbol` and some optional argument elements at the index positions `1..`
`boolean`	`isASTSizeGE(IExpr header, int length)` Test if this expression is an AST list, which contains the given header element at index position `0` and optional argument elements at the index positions `1..n`.
`boolean`	`isAtom()` Test if this expression is an atomic expression (i.e. no AST expression)
`boolean`	`isComplex()` Test if this expression is a symbolic complex number (i.e.
`boolean`	`isComplexInfinity()` Test if this expression is representing ComplexInfinity (i.e.
`boolean`	`isComplexNumeric()` Test if this expression is a numeric complex number (i.e.
`boolean`	`isCondition()` Test if this expression is the Condition function `Condition[<arg1>, <arg2>]`
`boolean`	`isCos()` Test if this expression is the function `Cos[<arg>]`
`boolean`	`isCosh()` Test if this expression is the function `Cosh[<arg>]`
`IAST[]`	`isDerivative()` Test if this expression is a `Derivative[number,...]`
`boolean`	`isDirectedInfinity()` Test if this expression is representing a DirectedInfinity (i.e.
`boolean`	`isEmpty()`
`boolean`	`isEvalFlagOff(int i)` Are the given evaluation flags disabled for this list ?
`boolean`	`isEvalFlagOn(int i)` Are the given evaluation flags enabled for this list ?
`boolean`	`isExpanded()` Test if this expression is already expanded i.e.
`boolean`	`isFlatAST()` Test if this expression is an AST list, which contains a header element (i.e. a function symbol like for example `Dot, Plus or Times`) with attribute `Flat` at index position `0` and some optional argument elements at the index positions `1..`
`boolean`	`isFraction()` Test if this expression is a fractional number, but no integer number.
`boolean`	`isFree(IExpr pattern)` Returns `true`, if all of the elements in the subexpressions or the expression itself, did not match the given pattern.
`boolean`	`isFree(IExpr pattern, boolean heads)` Returns `true`, if all of the elements in the subexpressions or the expression itself, did not match the given pattern.
`boolean`	`isFree(java.util.function.Predicate<IExpr> predicate, boolean heads)` Returns `true`, if all of the elements in the subexpressions or the expression itself, did not satisfy the given unary predicate.
`boolean`	`isFreeAST(IExpr pattern)` Returns `true`, if all of the elements in the subexpressions or the expression itself, aren't ASTs with a head which match the given pattern.
`boolean`	`isFreeAST(java.util.function.Predicate<IExpr> predicate)` Returns `true`, if all of the elements in the subexpressions or the expression itself, aren't ASTs with a head which match the given predicate.
`boolean`	`isFreeAt(int position, IExpr pattern)` Returns `true`, if all of the elements in the expressions or the expression itself at the given `position`, did not match the `pattern`.
`boolean`	`isFreeOfPatterns()` Returns `true`, if all of the elements in the subexpressions or the expression itself, are no pattern objects.
`boolean`	`isFunction()` Test if this expression is a `Function( arg1 )` expression with at least 1 argument.
`boolean`	`isGEOrdered(IExpr obj)` Compares this expression with the specified expression for order.
`boolean`	`isGTOrdered(IExpr obj)` Compares this expression with the specified expression for order.
`boolean`	`isInfinity()` Test if this expression is representing `Infinity` (i.e.
`boolean`	`isInteger()` Test if this expression is a integer number
`boolean`	`isIntegerResult()` Test if this expression is a integer function (i.e. a number, a symbolic constant or an integer function where all arguments are also "integer functions")
`boolean`	`isList()` Is this a list (i.e. with header == List)
`boolean`	`isListOfLists()` Test if this expression is a list of lists
`boolean`	`isLog()` Test if this expression is the function `Log[<arg>]`
`int[]`	`isMatrix()` Test if this expression is a matrix and return the dimensions as array [row-dimension, column-dimension].
`boolean`	`isMember(java.util.function.Predicate<IExpr> predicate, boolean heads)` Returns `true`, if at least one of the elements in the subexpressions or the expression itself, satisfy the given unary predicate.
`boolean`	`isModule()` Test if this expression is the Module function `Module[<arg1>, <arg2>]`
`boolean`	`isNegative()` Test if this object is a negative signed number.
`boolean`	`isNegativeInfinity()` Test if this expression is representing `-Infinity` (i.e.
`boolean`	`isNegativeResult()` Test if this expression has a negative result (i.e. less than 0).
`boolean`	`isNonNegativeResult()` Test if this expression has a non-negative result (i.e. greater equal 0).
`boolean`	`isNot()` Test if this expression is the function `Not[<arg>]`
`boolean`	`isNumber()` Test if this expression is a number.
`boolean`	`isNumeric()` Test if this expression is a numeric number (i.e. an instance of type `INum` or type `IComplexNum`.
`boolean`	`isNumericFunction()` Test if this expression is a numeric function (i.e. a number, a symbolic constant or a function (with attribute NumericFunction) where all arguments are also "numeric functions")
`boolean`	`isNumericMode()` Test if this expression contains a numeric number (i.e. of type `INum` or `IComplexNum`.
`boolean`	`isOr()` Test if this expression is the function `Or[<arg>,...]`
`boolean`	`isOrderlessAST()` Test if this expression is an AST list, which contains a header element (i.e. a function symbol like for example `Plus or Times`) with attribute `Orderless` at index position `0` and some optional argument elements at the index positions `1..n`.
`boolean`	`isPatternExpr()` Test if this expression or a subexpression is a pattern object.
`boolean`	`isPlus()` Test if this expression is the addition function `Plus[<arg1>, <arg2>, ...]`
`boolean`	`isPlusTimesPower()` Test if this expression is a `Plus, Power or Times` function.
`boolean`	`isPolynomial(IAST variables)` Test if this expression is a polynomial for the given list of `variables`.
`boolean`	`isPolynomial(ISymbol variable)` Test if this expression is a polynomial for the given `variable`.
`boolean`	`isPolynomialOfMaxDegree(IAST variables, long maxDegree)`
`boolean`	`isPolynomialOfMaxDegree(ISymbol variable, long maxDegree)` Test if this expression is a polynomial of `maxDegree` (i.e.
`boolean`	`isPositive()` Test if this object is a positive signed number.
`boolean`	`isPositiveResult()` Test if this expression has a positive result (i.e. greater than 0).
`boolean`	`isPower()` Test if this expression is the function `Power[<arg1>, <arg2>]`
`boolean`	`isRationalResult()` Test if this expression is a rational function (i.e. a number, a symbolic constant or an rational function where all arguments are also "rational functions")
`boolean`	`isRealResult()` Test if this expression is a real function (i.e. a number, a symbolic constant or an integer function where all arguments are also "reals functions")
`boolean`	`isRuleAST()` Test if this expression is of the form `Rule[<arg1>, <arg2>]` or `RuleDelayed[<arg1>, <arg2>]`.
`boolean`	`isSame(IExpr expression)` Test if this expression equals the given expression.
`boolean`	`isSame(IExpr expression, double epsilon)` Test if this expression equals the given expression.
`boolean`	`isSameHead(IExpr head)` Check if the object at index 0 (i.e. the head of the list) is the same object as `head`
`boolean`	`isSameHead(IExpr head, int length)` Check if the object at index 0 (i.e. the head of the list) is the same object as `head` and if the size of the list equals `length`.
`boolean`	`isSameHead(IExpr head, int minLength, int maxLength)` Check if the object at index 0 (i.e. the head of the list) is the same object as `head` and if the size of the list is between `minLength` and `maxLength`.
`boolean`	`isSameHeadSizeGE(IExpr head, int length)` Check if the object at index 0 (i.e. the head of the list) is the same object as `head` and if the size of the list is greater or equal `length`.
`boolean`	`isSequence()` Test if this expression is a sequence (i.e. an AST with head Sequence)
`boolean`	`isSignedNumber()` Test if this expression is a signed number.
`boolean`	`isSin()` Test if this expression is the function `Sin[<arg>]`
`boolean`	`isSinh()` Test if this expression is the function `Sinh[<arg>]`
`boolean`	`isSlot()` Test if this expression is the function `Slot[<integer-value>]`
`boolean`	`isSlotSequence()` Test if this expression is the function `SlotSequence[<integer-value>]`
`boolean`	`isSpan()`
`boolean`	`isTan()` Test if this expression is the function `TAn[<arg>]`
`boolean`	`isTanh()` Test if this expression is the function `Tanh[<arg>]`
`boolean`	`isTimes()` Test if this expression is the multiplication function `Times[<arg1>, <arg2>, ...]`
`boolean`	`isUnit()` Test if this is a unit.
`boolean`	`isValue()` Returns `true`, if this symbol or ast expression is bound to a value (i.e. the evaluation returns an assigned value).
`int`	`isVector()` Test if this expression is a vector and return the dimension of the vector.
`java.util.Iterator<IExpr>`	`iterator()` Returns an iterator over the elements in this `IAST` starting with offset 1.
`java.util.Iterator<IExpr>`	`iterator0()` Returns an iterator over the elements in this list starting with offset 0.
`IExpr`	`last()` Get the last element of the `AST` list (i.e. get(size()-1).
`int`	`lastIndexOf(java.lang.Object object)`
`long`	`leafCount()` Count the number of leaves of this expression.
`java.util.List<IExpr>`	`leaves()` Get a list of the leaf expressions.
`IAST`	`map(java.util.function.Function<IExpr,IExpr> function)` Maps the elements of this IAST with the unary functor.
`IAST`	`map(IAST clonedResultAST, java.util.function.Function<IExpr,IExpr> function)` Maps the elements of this IAST with the unary functor.
`IAST`	`map(IAST resultAST, IAST secondAST, java.util.function.BiFunction<IExpr,IExpr,IExpr> function)` Maps the elements of this IAST with the elements of the `secondAST`.
`IAST`	`map(IExpr head, java.util.function.Function<IExpr,IExpr> function)` Maps the elements of this IAST with the unary functor.
`IAST`	`mapAt(IAST appendAST, IAST replacement, int position)` Maps the elements of this IAST with the unary functor `Functors.replaceArg(replacement, position)`, there `replacement` is an IAST at which the argument at the given position will be replaced by the currently mapped element and appends the element to `appendAST`.
`IAST`	`mapAt(IAST replacement, int position)` Maps the elements of this IAST with the unary functor `Functors.replaceArg(replacement, position)`, there `replacement` is an IAST at which the argument at the given position will be replaced by the currently mapped element.
`IExpr`	`minus(IExpr that)` Returns an `IExpr` whose value is `(this - that)`.
`IExpr`	`mod(IExpr that)`
`IExpr`	`multiply(IExpr that)` Additional multiply method which works like `times()` to fulfill groovy's method signature
`IExpr`	`negate()` Negate this.
`IExpr`	`negative()` Additional `negative` method, which works like opposite to fulfill groovy's method signature
`IExpr`	`opposite()` Returns an `IExpr` whose value is `(-1) * this`.
`IExpr`	`optional(IExpr that)` The `ExprNull.NIL#optional()` method always returns `that`.
`IExpr`	`or(IExpr that)`
`int`	`patternHashCode()` Calculate a special hash value to find a matching rule in a hash table
`IExpr`	`plus(IExpr that)` Returns an `IExpr` whose value is `(this + that)`.
`IExpr`	`power(IExpr that)` Returns an `IExpr` whose value is `(this ^ that)`.
`IExpr`	`power(long n)` Returns an `IExpr` whose value is `(this ^ n)`.
`IAST`	`prependClone(IExpr expr)` Prepend an expression to this list.
`ASTRange`	`range()` Get the range of elements [0..sizeOfAST[ of the AST
`ASTRange`	`range(int start)` Get the range of elements [start..sizeOfAST[ of the AST
`ASTRange`	`range(int start, int end)` Get the range of elements [start..end[ of the AST
`IExpr`	`remainder(IExpr that)` Remainder after division of this by S.
`IAST`	`removeAtClone(int position)` Create a shallow copy of this `IAST` instance (the elements themselves are not copied) and remove the element at the given `position`.
`IExpr`	`replaceAll(java.util.function.Function<IExpr,IExpr> function)` Replace all (sub-) expressions with the given unary function.
`IExpr`	`replaceAll(IAST astRules)` Replace all (sub-) expressions with the given rule set.
`IExpr`	`replacePart(IAST astRules)` Replace all subexpressions with the given rule set.
`IExpr`	`replaceRepeated(java.util.function.Function<IExpr,IExpr> function)` Repeatedly replace all (sub-) expressions with the given unary function.
`IExpr`	`replaceRepeated(IAST astRules)` Repeatedly replace all (sub-) expressions with the given rule set.
`IExpr`	`replaceSlots(IAST astSlots)` Replace all occurrences of Slot[<index>] expressions with the expression at the appropriate `index` in the given `slotsList`.
`IAST`	`setAtClone(int position, IExpr expr)` Create a shallow copy of this `IAST` instance (the elements themselves are not copied) and set the `expr` at the given `position`.
`void`	`setEvalFlags(int i)` Set the evaluation flags for this list.
`int`	`signum()` Deprecated.
`int`	`size()` Returns the number of elements in this `ArrayList`.
`IExpr`	`subtract(IExpr that)` Subtract S from this.
`IExpr`	`sum(IExpr that)` Sum of this and S.
`IExpr`	`times(IExpr that)` Returns an `IExpr` whose value is `(this * that)`.
`IExpr`	`timesDistributed(IExpr that)` Returns an `IExpr` whose value is `(this * that)`.
`ISymbol`	`topHead()` Returns the ISymbol of the IAST.
`java.lang.String`	`toScript()` Get a scripting compatible string representation.
`java.lang.String`	`toScriptFactory()` Get a scripting compatible string representation of the factory.
`java.lang.String`	`toString()`
`IExpr`	`variables2Slots(java.util.Map<IExpr,IExpr> map, java.util.Collection<IExpr> variableCollector)` Convert the variables (i.e. expressions of type `ISymbol` which aren't constants) in this expression into Slot[] s.

Methods inherited from class java.util.AbstractList
add, add, addAll, clear, listIterator, listIterator, remove, removeRange, set, subList

Methods inherited from class java.util.AbstractCollection
addAll, containsAll, remove, removeAll, retainAll, toArray, toArray

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.matheclipse.core.interfaces.IAST
addAll, addAll, addOneIdentity, arg1, arg2, arg3, arg4, arg5, asSet, setAtCopy

Methods inherited from interface org.matheclipse.core.interfaces.IExpr
evaluateHead, getField, head, ifPresent, isBlank, isConstant, isE, isFalse, isIndeterminate, isLEOrdered, isLTOrdered, isMember, isMinusOne, isNumEqualInteger, isNumEqualRational, isNumIntValue, isOne, isONE, isPattern, isPatternDefault, isPatternSequence, isPi, isPresent, isRational, isRationalValue, isSymbol, isTrue, isVariable, isZero, isZERO, multiply, ofNullable, orElse, orElseGet, orElseThrow, reciprocal

Methods inherited from interface java.util.List
add, add, addAll, addAll, clear, containsAll, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, sort, spliterator, subList, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

- Field Detail
  - fEvalFlags
```
protected int fEvalFlags
```
    Flags for controlling evaluation and left-hand-side pattern-matching expressions
  - hashValue
```
protected transient int hashValue
```
- Constructor Detail
  - AbstractAST
```
public AbstractAST()
```
- Method Detail
  - $div
```
public final IExpr $div(IExpr that)
```
    Description copied from interface: IExpr
    
    Operator overloading for Scala operator /. Calls divide(that).
    
    Specified by:
    
    $div in interface IExpr
    
    Returns:
  - $minus
```
public final IExpr $minus(IExpr that)
```
    Description copied from interface: IExpr
    
    Operator overloading for Scala operator /. Calls divide(that).
    
    Specified by:
    
    $minus in interface IExpr
    
    Returns:
  - $plus
```
public final IExpr $plus(IExpr that)
```
    Description copied from interface: IExpr
    
    Operator overloading for Scala operator +. Calls plus(that).
    
    Specified by:
    
    $plus in interface IExpr
    
    Returns:
  - $times
```
public final IExpr $times(IExpr that)
```
    Description copied from interface: IExpr
    
    Operator overloading for Scala operator *. Calls times(that).
    
    Specified by:
    
    $times in interface IExpr
    
    Returns:
  - $up
```
public final IExpr $up(IExpr that)
```
    Description copied from interface: IExpr
    
    Operator overloading for Scala operator ^. Calls power(that).
    
    Specified by:
    
    $up in interface IExpr
    
    Returns:
  - abs
```
public IExpr abs()
```
    Description copied from interface: edu.jas.structure.AbelianGroupElem
    
    Absolute value of this.
    
    Specified by:
    
    abs in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Returns:
    
    |this|.
  - accept
```
public final <T> T accept(IVisitor<T> visitor)
```
    Accept a visitor with return type T
    
    Specified by:
    
    accept in interface IExpr
  - accept
```
public final boolean accept(IVisitorBoolean visitor)
```
    Accept a visitor with return type boolean
    
    Specified by:
    
    accept in interface IExpr
  - accept
```
public final int accept(IVisitorInt visitor)
```
    Accept a visitor with return type int
    
    Specified by:
    
    accept in interface IExpr
    
    Returns:
  - accept
```
public long accept(IVisitorLong visitor)
```
    Accept a visitor with return type long
    
    Specified by:
    
    accept in interface IExpr
    
    Returns:
  - addAtClone
```
public IAST addAtClone(int position,
                       IExpr expr)
```
    Create a shallow copy of this IAST instance (the elements themselves are not copied) and add the expr at the given position.
    
    Specified by:
    
    addAtClone in interface IAST
    
    Returns:
    
    a clone with added expr element at the given position.
  - addEvalFlags
```
public final void addEvalFlags(int i)
```
    Add an evaluation flag to the existing ones.
    
    Specified by:
    
    addEvalFlags in interface IAST
  - and
```
public IExpr and(IExpr that)
```
    Specified by:
    
    and in interface IExpr
  - appendClone
```
public IAST appendClone(IExpr expr)
```
    Append an expression to this list.
    
    Specified by:
    
    appendClone in interface IAST
    
    Returns:
    
    this after appending the given expression.
  - apply
```
public IAST apply(IExpr head)
```
    Description copied from interface: IAST
    
    Apply the given head to this expression (i.e. create a list clone and replace the old head with the given one)
    
    Specified by:
    
    apply in interface IAST
    
    Returns:
  - apply
```
public IExpr apply(IExpr... leaves)
```
    Specified by:
    
    apply in interface IExpr
    
    Returns:
    
    an IExpr instance with the current expression as head(), and leaves as leaves().
  - apply
```
public final IAST apply(IExpr head,
                        int start)
```
    Description copied from interface: IAST
    
    Apply the given head to this expression (i.e. create a sublist clone starting from index start and replacing the old head with the given one)
    
    Specified by:
    
    apply in interface IAST
    
    Returns:
  - apply
```
public IAST apply(IExpr head,
                  int start,
                  int end)
```
    Description copied from interface: IAST
    
    Apply the given head to this expression (i.e. create a sublist clone from index start to end, and replacing the old head with the given one)
    
    Specified by:
    
    apply in interface IAST
    
    Returns:
    
    a clone with element set to head at the given 0.
  - apply
```
public IExpr apply(java.util.List<? extends IExpr> leaves)
```
    Specified by:
    
    apply in interface IExpr
    
    Returns:
    
    an IExpr instance with the current expression as head(), and leaves as leaves().
  - args
```
public final ASTRange args()
```
    Get the range of elements [1..ast.size()[. These range elements are the arguments of a function (represented as an AST).
    
    Specified by:
    
    args in interface IAST
    
    Returns:
  - asType
```
public java.lang.Object asType(java.lang.Class<?> clazz)
```
    Specified by:
    
    asType in interface IExpr
  - clearHashCache
```
public void clearHashCache()
```
    Description copied from interface: IAST
    
    Set the cached hash value to zero.
    
    Specified by:
    
    clearHashCache in interface IAST
  - clone
```
public IAST clone()
```
    Description copied from interface: IAST
    
    Returns a shallow copy of this IAST instance (the elements themselves are not cloned).
    
    Specified by:
    
    clone in interface IAST
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    
    a clone of this IAST instance.
  - compareTo
```
public int compareTo(IExpr rhsExpr)
```
    Compares this expression with the specified expression for canonical order. Returns a negative integer, zero, or a positive integer as this expression is canonical less than, equal to, or greater than the specified expression.
    
    Specified by:
    
    compareTo in interface edu.jas.structure.Element<IExpr>
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<IExpr>
    
    Specified by:
    
    compareTo in interface IExpr
    
    Returns:
    
    0 if this is equal to b, -1 if this is less then b, else +1.
  - contains
```
public boolean contains(java.lang.Object object)
```
    Specified by:
    
    contains in interface java.util.Collection<IExpr>
    
    Specified by:
    
    contains in interface java.util.List<IExpr>
    
    Overrides:
    
    contains in class java.util.AbstractCollection<IExpr>
  - copy
```
public IAST copy()
```
    Description copied from interface: IAST
    
    Returns a shallow copy of this IAST instance (the elements themselves are not copied). In contrast to the clone() method, this method returns exactly the same type for AST0, AST1, AST2,AST3.
    
    Specified by:
    
    copy in interface edu.jas.structure.Element<IExpr>
    
    Specified by:
    
    copy in interface IAST
    
    Returns:
    
    a copy of this IAST instance.
  - copyFrom
```
public IAST copyFrom(int index)
```
    Create a copy of this AST, which contains the same head and all elements from to the given position (inclusive).
    
    Specified by:
    
    copyFrom in interface IAST
  - copyHead
```
public final IAST copyHead()
```
    Create a copy of this AST, which only contains the head element of the list (i.e. the element with index 0).
    
    Specified by:
    
    copyHead in interface IAST
  - copyUntil
```
public final IAST copyUntil(int index)
```
    Create a copy of this AST, which contains the same head and all elements up to the given position (exclusive).
    
    Specified by:
    
    copyUntil in interface IAST
  - copyUntil
```
public final IAST copyUntil(int intialCapacity,
                            int index)
```
    Create a copy of this AST, which contains the same head and all elements up to the given position (exclusive).
    
    Specified by:
    
    copyUntil in interface IAST
    
    Parameters:
    
    intialCapacity - the initial capacity of elements
  - dec
```
public final IExpr dec()
```
    Returns an IExpr whose value is (this - 1). Calculates F.eval(F.Subtract(this, C1)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    dec in interface IExpr
    
    Returns:
  - divide
```
public final IExpr divide(IExpr that)
```
    Returns an IExpr whose value is (this / that). Calculates F.eval(F.Times(this, F.Power(that, F.CN1))) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    divide in interface edu.jas.structure.MonoidElem<IExpr>
    
    Specified by:
    
    divide in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    divide in interface IExpr
    
    Parameters:
    
    that - element to divide by
    
    Returns:
    
    this / S.
  - egcd
```
public final IExpr[] egcd(IExpr b)
```
    Description copied from interface: edu.jas.structure.RingElem
    
    Extended greatest common divisor.
    
    Specified by:
    
    egcd in interface edu.jas.structure.RingElem<IExpr>
    
    Parameters:
    
    b - other element.
    
    Returns:
    
    [ gcd(this,b), c1, c2 ] with c1*this + c2*b = gcd(this,b).
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Description copied from interface: edu.jas.structure.Element
    
    Test if this is equal to b.
    
    Specified by:
    
    equals in interface edu.jas.structure.Element<IExpr>
    
    Specified by:
    
    equals in interface java.util.Collection<IExpr>
    
    Specified by:
    
    equals in interface java.util.List<IExpr>
    
    Overrides:
    
    equals in class java.util.AbstractList<IExpr>
    
    Returns:
    
    true if this is equal to b, else false.
  - equalsAt
```
public final boolean equalsAt(int position,
                              IExpr expr)
```
    Calls get(position).equals(expr).
    
    Specified by:
    
    equalsAt in interface IAST
    
    expr - the expr which should be test for equality
  - equalsFromPosition
```
public final boolean equalsFromPosition(int from0,
                                        IAST f1,
                                        int from1)
```
  - evalComplex
```
public final org.apache.commons.math4.complex.Complex evalComplex()
```
    Evaluate the expression to a INumber value.
    
    Specified by:
    
    evalComplex in interface IExpr
    
    Returns:
    
    null if the conversion is not possible.
  - evalDouble
```
public final double evalDouble()
```
    Evaluate the expression to a Java double value. If the conversion to a double value is not possible, the method throws a WrongArgumentType exception.
    
    Specified by:
    
    evalDouble in interface IExpr
    
    Returns:
    
    this expression converted to a Java double value.
  - evalNumber
```
public final INumber evalNumber()
```
    Evaluate the expression to a INumber value.
    
    Specified by:
    
    evalNumber in interface IExpr
    
    Returns:
    
    null if the conversion is not possible.
  - evalSignedNumber
```
public final ISignedNumber evalSignedNumber()
```
    Evaluate the expression to a ISignedNumber value.
    
    Specified by:
    
    evalSignedNumber in interface IExpr
    
    Returns:
    
    null if the conversion is not possible.
  - evaluate
```
public IExpr evaluate(EvalEngine engine)
```
    Description copied from interface: IExpr
    
    Evaluate an expression
    
    Specified by:
    
    evaluate in interface IExpr
    
    Parameters:
    
    engine - the evaluation engine
    
    Returns:
    
    the evaluated Object or F.NIL if the evaluation is not possible (i.e. the evaluation doesn't change the object).
  - factory
```
public final edu.jas.structure.ElemFactory<IExpr> factory()
```
    Description copied from interface: edu.jas.structure.Element
    
    Get the corresponding element factory.
    
    Specified by:
    
    factory in interface edu.jas.structure.Element<IExpr>
    
    Returns:
    
    factory for this Element.
  - filter
```
public final IAST[] filter(java.util.function.Function<IExpr,IExpr> function)
```
    Select all elements by applying the function to each argument in this AST and append the result elements for which the function returns non-null elements to the 0th element of the result array, or otherwise append it to the 1st element of the result array.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    function - the function which filters each argument in this AST by returning a non-null result.
    
    Returns:
    
    the resulting ASTs in the 0-th and 1-st element of the array
  - filter
```
public final IAST filter(IAST filterAST,
                         IAST restAST,
                         java.util.function.Function<IExpr,IExpr> function)
```
    Select all elements by applying the function to each argument in this AST and append the result elements for which the function returns non-null elements to the filterAST, or otherwise append the argument to the restAST.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    filterAST - the non-null elements which were returned by the function#apply() method
    
    restAST - the arguments in this AST for which the function#apply() method returned null
    
    function - the function which filters each argument by returning a possibly non-null value.
    
    Returns:
    
    the given filterAST
  - filter
```
public final IAST filter(IAST filterAST,
                         IAST restAST,
                         java.util.function.Predicate<? super IExpr> predicate)
```
    Select all elements by applying the predicate to each argument in this AST and append the elements which satisfy the predicate to the filterAST, or otherwise append it to the restAST.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    filterAST - the elements where the predicate#apply() method returns true
    
    restAST - the elements which don't match the predicate
    
    predicate - the predicate which filters each argument in this AST
    
    Returns:
    
    the filterAST
  - filter
```
public final IAST filter(IAST filterAST,
                         IExpr expr)
```
    Select all elements by applying the Predicates.isTrue(expr) predicate to each argument in this AST and append the elements which satisfy the Predicates.isTrue(expr) predicate to the filterAST.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    filterAST - the elements where the predicate#apply() method returns true
    
    expr - create a Predicates.isTrue(expr) predicate which filters each element in this AST.
    
    Returns:
    
    the filterAST
  - filter
```
public final IAST filter(IAST filterAST,
                         java.util.function.Predicate<? super IExpr> predicate)
```
    Select all elements by applying the predicate to each argument in this AST and append the arguments which satisfy the predicate to the filterAST.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    filterAST - the elements where the predicate#apply() method returns true
    
    predicate - the predicate which filters each argument in this AST
    
    Returns:
    
    the filterAST
  - filter
```
public final IAST filter(IAST filterAST,
                         java.util.function.Predicate<? super IExpr> predicate,
                         int maxMatches)
```
    Select all elements by applying the predicate to each argument in this AST and append up to maxMatches arguments which satisfy the predicate to the filterAST.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    filterAST - the elements where the predicate#apply() method returns true
    
    predicate - the predicate which filters each argument in this AST
    
    Returns:
    
    the filterAST
  - filter
```
public final IAST[] filter(java.util.function.Predicate<? super IExpr> predicate)
```
    Select all elements by applying the predicate to each argument in this AST and append the arguments which satisfy the predicate to the 0th element of the result array, or otherwise append it to the 1st element of the result array.
    
    Specified by:
    
    filter in interface IAST
    
    Parameters:
    
    predicate - the predicate which filters each element in the range
    
    Returns:
    
    the resulting ASTs in the 0-th and 1-st element of the array
  - findFirstEquals
```
public final int findFirstEquals(IExpr expr)
```
    Description copied from interface: IAST
    
    Find the first argument position, which equals expr. The serarch starts at index 1.
    
    Specified by:
    
    findFirstEquals in interface IAST
    
    Returns:
    
    -1 if no position was found
  - forEach
```
public void forEach(java.util.function.Consumer<? super IExpr> action)
```
    Description copied from interface: IAST
    
    Iterate over all elements from index 1 to size()-1 and call the method Consumer.accept() for these elements.
    Note: the 0-th element (i.e. the head of the AST) will not be selected.
    
    Specified by:
    
    forEach in interface java.lang.Iterable<IExpr>
    
    Specified by:
    
    forEach in interface IAST
  - fullFormString
```
public final java.lang.String fullFormString()
```
    Description copied from interface: IExpr
    
    Return the FullForm() of this expression
    
    Specified by:
    
    fullFormString in interface IExpr
  - gcd
```
public final IExpr gcd(IExpr that)
```
    Description copied from interface: edu.jas.structure.RingElem
    
    Greatest common divisor.
    
    Specified by:
    
    gcd in interface edu.jas.structure.RingElem<IExpr>
    
    Parameters:
    
    that - other element.
    
    Returns:
    
    gcd(this,b).
  - get
```
public IExpr get(int location)
```
    Specified by:
    
    get in interface java.util.List<IExpr>
    
    Specified by:
    
    get in class java.util.AbstractList<IExpr>
  - getAST
```
public final IAST getAST(int index)
```
    Casts an IExpr at position index to an IAST.
    
    Specified by:
    
    getAST in interface IAST
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    WrongArgumentType - if the cast is not possible
  - getAt
```
public final IExpr getAt(int index)
```
    Description copied from interface: IExpr
    
    Get the element at the specified index if this object is of type IAST.
    
    Specified by:
    
    getAt in interface IExpr
    
    Returns:
  - getEvalFlags
```
public final int getEvalFlags()
```
    Get the evaluation flags for this list.
    
    Specified by:
    
    getEvalFlags in interface IAST
    
    Returns:
  - getHashCache
```
public int getHashCache()
```
    Description copied from interface: IAST
    
    Get the cached hash value.
    
    Specified by:
    
    getHashCache in interface IAST
    
    Returns:
  - getInt
```
public final IInteger getInt(int index)
```
    Casts an IExpr at position index to an IInteger.
    
    Specified by:
    
    getInt in interface IAST
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    WrongArgumentType - if the cast is not possible
  - getList
```
public final IAST getList(int index)
```
    Casts an IExpr which is a list at position index to an IAST.
    
    Specified by:
    
    getList in interface IAST
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    WrongArgumentType
  - getNumber
```
public final INumber getNumber(int index)
```
    Casts an IExpr at position index to an INumber.
    
    Specified by:
    
    getNumber in interface IAST
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    WrongArgumentType - if the cast is not possible
  - getOneIdentity
```
public final IExpr getOneIdentity(IExpr defaultValue)
```
    Get the argument at index 1, if the size() == 2 or the complete ast if the size() > 2 (useful for ASTs with attribute OneIdentity for example for Plus[] you can call getOneIdentity(F.C0) or for Times[]) you can call getOneIdentity(F.C1).
    
    Specified by:
    
    getOneIdentity in interface IAST
    
    Parameters:
    
    defaultValue - default value, if size() < 2.
    
    Returns:
  - getPart
```
public final IExpr getPart(int... positions)
```
    Description copied from interface: IAST
    
    Returns the element at the specified positions in the nested ASTs.
    
    Specified by:
    
    getPart in interface IAST
    
    Parameters:
    
    positions - index of the element to return
    
    Returns:
    
    the element at the specified positions in this nested AST
  - getPart
```
public final IExpr getPart(java.util.List<java.lang.Integer> positions)
```
    Description copied from interface: IAST
    
    Returns the element at the specified positions in the nested ASTs.
    
    Specified by:
    
    getPart in interface IAST
    
    Parameters:
    
    positions - index of the element to return
    
    Returns:
    
    the element at the specified positions in this nested AST
  - hashCode
```
public int hashCode()
```
    Description copied from interface: edu.jas.structure.Element
    
    Hashcode of this Element.
    
    Specified by:
    
    hashCode in interface edu.jas.structure.Element<IExpr>
    
    Specified by:
    
    hashCode in interface java.util.Collection<IExpr>
    
    Specified by:
    
    hashCode in interface java.util.List<IExpr>
    
    Overrides:
    
    hashCode in class java.util.AbstractList<IExpr>
    
    Returns:
    
    the hashCode.
  - hierarchy
```
public final int hierarchy()
```
    A unique integer ID for the implementation of this expression
    
    Specified by:
    
    hierarchy in interface IExpr
    
    Returns:
    
    a unique integer id for the implementation of this expression
  - inc
```
public final IExpr inc()
```
    Returns an IExpr whose value is (this + 1). Calculates F.eval(F.Plus(this, C1)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    inc in interface IExpr
    
    Returns:
  - indexOf
```
public final int indexOf(java.lang.Object object)
```
    Specified by:
    
    indexOf in interface java.util.List<IExpr>
    
    Overrides:
    
    indexOf in class java.util.AbstractList<IExpr>
  - internalFormString
```
public final java.lang.String internalFormString(boolean symbolsAsFactoryMethod,
                                                 int depth)
```
    Return the internal Java form of this expression.
    
    Specified by:
    
    internalFormString in interface IExpr
    
    Parameters:
    
    symbolsAsFactoryMethod - if true use the F.symbol() method, otherwise print the symbol name.
    
    depth - the recursion depth of this call. 0 indicates "recurse without a limit".
  - internalJavaString
```
public final java.lang.String internalJavaString(boolean symbolsAsFactoryMethod,
                                                 int depth,
                                                 boolean useOperators)
```
    Return the internal Java form of this expression.
    
    Specified by:
    
    internalJavaString in interface IExpr
    
    Parameters:
    
    symbolsAsFactoryMethod - if true use the F.symbol() method, otherwise print the symbol name.
    
    depth - the recursion depth of this call. 0 indicates "recurse without a limit".
    
    useOperators - use operators instead of function names for representation of Plus, Times, Power,...
  - internalScalaString
```
public final java.lang.String internalScalaString(boolean symbolsAsFactoryMethod,
                                                  int depth)
```
    Return the internal Scala form of this expression.
    
    Specified by:
    
    internalScalaString in interface IExpr
    
    Parameters:
    
    symbolsAsFactoryMethod - if true use the F.symbol() method, otherwise print the symbol name.
    
    depth - the recursion depth of this call. 0 indicates "recurse without a limit".
  - inverse
```
public IExpr inverse()
```
    Description copied from interface: IExpr
    
    Returns the multiplicative inverse of this object. It is the object such as this.times(this.inverse()) == ONE , with ONE being the multiplicative identity. Calculates F.eval(F.Power(this, F.CN1)) in the common case and uses a specialized implmentation for derived number classes.
    
    Specified by:
    
    inverse in interface edu.jas.structure.MonoidElem<IExpr>
    
    Specified by:
    
    inverse in interface IExpr
    
    Returns:
    
    ONE / this.
  - isAllExpanded
```
public boolean isAllExpanded()
```
    Test if this expression and all subexpressions are already expanded i.e. all Plus, Times, Power (sub-)expressions are expanded.
    
    Specified by:
    
    isAllExpanded in interface IExpr
  - isAnd
```
public final boolean isAnd()
```
    Test if this expression is the function And[<arg>,...]
    
    Specified by:
    
    isAnd in interface IExpr
  - isArcCos
```
public final boolean isArcCos()
```
    Test if this expression is the function ArcCos[<arg>]
    
    Specified by:
    
    isArcCos in interface IExpr
  - isArcCosh
```
public final boolean isArcCosh()
```
    Test if this expression is the function ArcCosh[<arg>]
    
    Specified by:
    
    isArcCosh in interface IExpr
  - isArcSin
```
public final boolean isArcSin()
```
    Test if this expression is the function ArcSin[<arg>]
    
    Specified by:
    
    isArcSin in interface IExpr
  - isArcSinh
```
public final boolean isArcSinh()
```
    Test if this expression is the function ArcSinh[<arg>]
    
    Specified by:
    
    isArcSinh in interface IExpr
  - isArcTan
```
public final boolean isArcTan()
```
    Test if this expression is the function ArcTan[<arg>]
    
    Specified by:
    
    isArcTan in interface IExpr
  - isArcTanh
```
public final boolean isArcTanh()
```
    Test if this expression is the function ArcTanh[<arg>]
    
    Specified by:
    
    isArcTanh in interface IExpr
  - isAST
```
public boolean isAST()
```
    Test if this expression is an AST list, which contains a header element (i.e. the function name) at index position 0 and some optional argument elements at the index positions 1..n. Therefore this expression is no atomic expression.
    
    Specified by:
    
    isAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public boolean isAST(IExpr header)
```
    Test if this expression is an AST list, which contains the given header element at index position 0 and some optional argument elements at the index positions 1..(size()-1). Therefore this expression is not an atomic expression.
    
    Specified by:
    
    isAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public final boolean isAST(IExpr header,
                           int length)
```
    Test if this expression is an AST list, which contains the given header element at index position 0 and optional argument elements at the index positions 1..(length-1). Therefore this expression is not an atomic expression.
    
    Specified by:
    
    isAST in interface IExpr
    
    Parameters:
    
    header - the header element to chck for
    
    length - the length the AST expression must have
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public boolean isAST(IExpr header,
                     int length,
                     IExpr... args)
```
    Test if this expression is an AST list, which contains the given header element at index position 0 and optional argument elements at the index positions 1..(length-1). Therefore this expression is not an atomic expression.
    
    Specified by:
    
    isAST in interface IExpr
    
    args - the arguments of this AST which should be tested, if they are equal, a null value argument skips the equals chack.
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public final boolean isAST(IExpr header,
                           int minLength,
                           int maxLength)
```
    Test if this expression is an AST list, which contains the given header element at index position 0 and optional argument elements at the index positions 1..(length-1). Therefore this expression is not an atomic expression.
    
    Specified by:
    
    isAST in interface IExpr
    
    Parameters:
    
    header - the header element to chck for
    
    minLength - the minimum size the AST expression must have
    
    maxLength - the maximum size the AST expression must have
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public final boolean isAST(java.lang.String symbol)
```
    Test if this expression is an AST list, where the string representation of the header element at index position 0 equals the given symbol and some optional argument elements at the index positions 1..(size()-1). Therefore this expression is no atomic expression. Example: isAST("Sin") gives true for Sin[Pi/2].
    
    Specified by:
    
    isAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isAST
```
public final boolean isAST(java.lang.String symbol,
                           int length)
```
    Test if this expression is an AST list, where the string representation of the header element at index position 0 equals the given symbol and some optional argument elements at the index positions 1..(length-1). Therefore this expression is no atomic expression. Example: isAST("Sin", 2) gives true for Sin[0].
    
    Specified by:
    
    isAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isASTSizeGE
```
public final boolean isASTSizeGE(IExpr header,
                                 int length)
```
    Test if this expression is an AST list, which contains the given header element at index position 0 and optional argument elements at the index positions 1..n. n must be greater equal than the given length. Therefore this expression is no atomic expression.
    
    Specified by:
    
    isASTSizeGE in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isAtom
```
public final boolean isAtom()
```
    Description copied from interface: IExpr
    
    Test if this expression is an atomic expression (i.e. no AST expression)
    
    Specified by:
    
    isAtom in interface IExpr
  - isComplex
```
public final boolean isComplex()
```
    Test if this expression is a symbolic complex number (i.e. instanceof IComplex)
    
    Specified by:
    
    isComplex in interface IExpr
  - isComplexInfinity
```
public final boolean isComplexInfinity()
```
    Test if this expression is representing ComplexInfinity (i.e. DirectedInfinity[])
    
    Specified by:
    
    isComplexInfinity in interface IExpr
  - isComplexNumeric
```
public final boolean isComplexNumeric()
```
    Test if this expression is a numeric complex number (i.e. instanceof IComplexNum)
    
    Specified by:
    
    isComplexNumeric in interface IExpr
  - isCondition
```
public final boolean isCondition()
```
    Test if this expression is the Condition function Condition[<arg1>, <arg2>]
    
    Specified by:
    
    isCondition in interface IExpr
  - isCos
```
public final boolean isCos()
```
    Test if this expression is the function Cos[<arg>]
    
    Specified by:
    
    isCos in interface IExpr
  - isCosh
```
public final boolean isCosh()
```
    Test if this expression is the function Cosh[<arg>]
    
    Specified by:
    
    isCosh in interface IExpr
  - isDerivative
```
public final IAST[] isDerivative()
```
    Test if this expression is a Derivative[number,...][symbol][arg] or Derivative[number,...][symbol] expression and return the corresponding IAST structures.
    - The expression at index [0] contains the Derivative[number,...] AST part.
    - The expression at index [1] contains the Derivative[...][symbol] AST part.
    - The expression at index [2] contains the Derivative[...][...][arg] AST part, if available.
    Note: the result at index [2] maybe null , if no argument is available.
    Specified by:
    
    isDerivative in interface IExpr
    
    Returns:
    
    null if the expression is not a Derivative[number,...][symbol][arg] or Derivative[number,...][symbol] expression.
  - isDirectedInfinity
```
public final boolean isDirectedInfinity()
```
    Test if this expression is representing a DirectedInfinity (i.e. Infinity->DirectedInfinity[1], -Infinity->DirectedInfinity[-1], ComplexInfinity->DirectedInfinity[])
    
    Specified by:
    
    isDirectedInfinity in interface IExpr
  - isEmpty
```
public final boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<IExpr>
    
    Specified by:
    
    isEmpty in interface java.util.List<IExpr>
    
    Overrides:
    
    isEmpty in class java.util.AbstractCollection<IExpr>
  - isEvalFlagOff
```
public final boolean isEvalFlagOff(int i)
```
    Are the given evaluation flags disabled for this list ?
    
    Specified by:
    
    isEvalFlagOff in interface IAST
    
    Returns:
  - isEvalFlagOn
```
public final boolean isEvalFlagOn(int i)
```
    Are the given evaluation flags enabled for this list ?
    
    Specified by:
    
    isEvalFlagOn in interface IAST
    
    Returns:
  - isExpanded
```
public final boolean isExpanded()
```
    Test if this expression is already expanded i.e. Plus, Times, Power expression is expanded.
    
    Specified by:
    
    isExpanded in interface IExpr
  - isFlatAST
```
public final boolean isFlatAST()
```
    Test if this expression is an AST list, which contains a header element (i.e. a function symbol like for example Dot, Plus or Times) with attribute Flat at index position 0 and some optional argument elements at the index positions 1..(size()-1). Examples for Flat functions are Dot[], Plus[] or Times[]. Therefore this expression is no atomic expression.
    
    Specified by:
    
    isFlatAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isFraction
```
public final boolean isFraction()
```
    Test if this expression is a fractional number, but no integer number.
    
    Specified by:
    
    isFraction in interface IExpr
  - isFree
```
public final boolean isFree(IExpr pattern)
```
    Returns true, if all of the elements in the subexpressions or the expression itself, did not match the given pattern. Calls isFree(pattern, true).
    
    Specified by:
    
    isFree in interface IExpr
    
    Parameters:
    
    pattern - a pattern-matching expression
  - isFree
```
public final boolean isFree(IExpr pattern,
                            boolean heads)
```
    Returns true, if all of the elements in the subexpressions or the expression itself, did not match the given pattern.
    
    Specified by:
    
    isFree in interface IExpr
    
    Parameters:
    
    pattern - a pattern-matching expression
    
    heads - if set to false, only the arguments of an IAST should be tested and not the Head[] element.
  - isFree
```
public final boolean isFree(java.util.function.Predicate<IExpr> predicate,
                            boolean heads)
```
    Returns true, if all of the elements in the subexpressions or the expression itself, did not satisfy the given unary predicate.
    
    Specified by:
    
    isFree in interface IExpr
    
    Parameters:
    
    predicate - a unary predicate
    
    heads - if set to false, only the arguments of an IAST should be tested and not the Head[] element.
  - isFreeAST
```
public final boolean isFreeAST(IExpr pattern)
```
    Returns true, if all of the elements in the subexpressions or the expression itself, aren't ASTs with a head which match the given pattern.
    
    Specified by:
    
    isFreeAST in interface IExpr
    
    Parameters:
    
    pattern - a pattern-matching expression
  - isFreeAST
```
public final boolean isFreeAST(java.util.function.Predicate<IExpr> predicate)
```
    Returns true, if all of the elements in the subexpressions or the expression itself, aren't ASTs with a head which match the given predicate.
    
    Specified by:
    
    isFreeAST in interface IExpr
  - isFreeAt
```
public final boolean isFreeAt(int position,
                              IExpr pattern)
```
    Returns true, if all of the elements in the expressions or the expression itself at the given position, did not match the pattern. Calls get(Position).isFree(pattern, true).
    
    Specified by:
    
    isFreeAt in interface IAST
    
    pattern - a pattern-matching expression
  - isFreeOfPatterns
```
public final boolean isFreeOfPatterns()
```
    Returns true, if all of the elements in the subexpressions or the expression itself, are no pattern objects.
    
    Specified by:
    
    isFreeOfPatterns in interface IExpr
    
    Returns:
    
    true if the expression contains no IPatternObject.
  - isFunction
```
public final boolean isFunction()
```
    Test if this expression is a Function( arg1 ) expression with at least 1 argument.
    
    Specified by:
    
    isFunction in interface IExpr
  - isGEOrdered
```
public final boolean isGEOrdered(IExpr obj)
```
    Compares this expression with the specified expression for order. Returns true if this expression is canonical greater than or equal to the specified expression (<= relation).
    
    Specified by:
    
    isGEOrdered in interface IExpr
    
    Parameters:
    
    obj - an expression to compare with
    
    Returns:
    
    true if this expression is canonical greater than or equal to the specified expression.
  - isGTOrdered
```
public final boolean isGTOrdered(IExpr obj)
```
    Compares this expression with the specified expression for order. Returns true if this expression is canonical greater than the specified expression (< relation).
    
    Specified by:
    
    isGTOrdered in interface IExpr
    
    Parameters:
    
    obj - an expression to compare with
    
    Returns:
    
    true if this expression is canonical greater than the specified expression.
  - isInfinity
```
public final boolean isInfinity()
```
    Test if this expression is representing Infinity (i.e. Infinity->DirectedInfinity[1])
    
    Specified by:
    
    isInfinity in interface IExpr
  - isInteger
```
public final boolean isInteger()
```
    Test if this expression is a integer number
    
    Specified by:
    
    isInteger in interface IExpr
  - isIntegerResult
```
public final boolean isIntegerResult()
```
    Test if this expression is a integer function (i.e. a number, a symbolic constant or an integer function where all arguments are also "integer functions")
    
    Specified by:
    
    isIntegerResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a integer function or value.
    
    See Also:
    
    #isRealFunction
  - isList
```
public final boolean isList()
```
    Is this a list (i.e. with header == List)
    
    Specified by:
    
    isList in interface IAST
    
    Specified by:
    
    isList in interface IExpr
  - isListOfLists
```
public final boolean isListOfLists()
```
    Test if this expression is a list of lists
    
    Specified by:
    
    isListOfLists in interface IExpr
    
    See Also:
    
    IExpr.isList(), IExpr.isMatrix(), IExpr.isVector()
  - isLog
```
public final boolean isLog()
```
    Test if this expression is the function Log[<arg>]
    
    Specified by:
    
    isLog in interface IExpr
  - isMatrix
```
public final int[] isMatrix()
```
    Test if this expression is a matrix and return the dimensions as array [row-dimension, column-dimension]. This expression is only a matrix, if all elements are lists with the header List and have the same size.
    
    Specified by:
    
    isMatrix in interface IExpr
    
    Returns:
    
    null if the expression is not a matrix
  - isMember
```
public final boolean isMember(java.util.function.Predicate<IExpr> predicate,
                              boolean heads)
```
    Returns true, if at least one of the elements in the subexpressions or the expression itself, satisfy the given unary predicate.
    
    Specified by:
    
    isMember in interface IExpr
    
    Parameters:
    
    predicate - a unary predicate
    
    heads - if set to false, only the arguments of an IAST should be tested and not the Head[] element.
  - isModule
```
public final boolean isModule()
```
    Test if this expression is the Module function Module[<arg1>, <arg2>]
    
    Specified by:
    
    isModule in interface IExpr
  - isNegative
```
public final boolean isNegative()
```
    Test if this object is a negative signed number. For an IAST object the method checks, if it is a numeric constant. If the IAST object evaluates to a negative numeric expression this method returns true.
    
    Specified by:
    
    isNegative in interface IExpr
    
    Returns:
    
    true, if this < 0; false in all other case.
  - isNegativeInfinity
```
public final boolean isNegativeInfinity()
```
    Test if this expression is representing -Infinity (i.e. -Infinity->DirectedInfinity[-1])
    
    Specified by:
    
    isNegativeInfinity in interface IExpr
  - isNegativeResult
```
public final boolean isNegativeResult()
```
    Test if this expression has a negative result (i.e. less than 0).
    
    Specified by:
    
    isNegativeResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a negative function or value.
    
    See Also:
    
    #isRealFunction
  - isNonNegativeResult
```
public final boolean isNonNegativeResult()
```
    Test if this expression has a non-negative result (i.e. greater equal 0).
    
    Specified by:
    
    isNonNegativeResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a non-negative function or value.
    
    See Also:
    
    #isRealFunction
  - isNot
```
public final boolean isNot()
```
    Test if this expression is the function Not[<arg>]
    
    Specified by:
    
    isNot in interface IExpr
  - isNumber
```
public final boolean isNumber()
```
    Description copied from interface: IExpr
    
    Test if this expression is a number. I.e. an instance of type INumber.
    
    Specified by:
    
    isNumber in interface IExpr
  - isNumeric
```
public final boolean isNumeric()
```
    Test if this expression is a numeric number (i.e. an instance of type INum or type IComplexNum.
    
    Specified by:
    
    isNumeric in interface IExpr
  - isNumericFunction
```
public final boolean isNumericFunction()
```
    Test if this expression is a numeric function (i.e. a number, a symbolic constant or a function (with attribute NumericFunction) where all arguments are also "numeric functions")
    
    Specified by:
    
    isNumericFunction in interface IExpr
    
    Returns:
    
    true, if the given expression is a numeric function or value.
    
    See Also:
    
    #isRealFunction
  - isNumericMode
```
public final boolean isNumericMode()
```
    Test if this expression contains a numeric number (i.e. of type INum or IComplexNum.
    
    Specified by:
    
    isNumericMode in interface IExpr
    
    Returns:
    
    true, if the given expression contains numeric number (i.e. of type INum or IComplexNum.
    
    See Also:
    
    #isRealFunction
  - isOr
```
public final boolean isOr()
```
    Test if this expression is the function Or[<arg>,...]
    
    Specified by:
    
    isOr in interface IExpr
  - isOrderlessAST
```
public final boolean isOrderlessAST()
```
    Test if this expression is an AST list, which contains a header element (i.e. a function symbol like for example Plus or Times) with attribute Orderless at index position 0 and some optional argument elements at the index positions 1..n. Examples for Orderless functions are Plus[] or Times[]. Therefore this expression is no atomic expression.
    
    Specified by:
    
    isOrderlessAST in interface IExpr
    
    See Also:
    
    IExpr.isAtom()
  - isPatternExpr
```
public final boolean isPatternExpr()
```
    Test if this expression or a subexpression is a pattern object. Used in pattern-matching; checks flags in IAST with flag IAST.CONTAINS_PATTERN_EXPR.
    
    Specified by:
    
    isPatternExpr in interface IExpr
  - isPlus
```
public final boolean isPlus()
```
    Test if this expression is the addition function Plus[<arg1>, <arg2>, ...]
    
    Specified by:
    
    isPlus in interface IAST
    
    Specified by:
    
    isPlus in interface IExpr
  - isPlusTimesPower
```
public boolean isPlusTimesPower()
```
    Test if this expression is a Plus, Power or Times function.
    
    Specified by:
    
    isPlusTimesPower in interface IExpr
  - isPolynomial
```
public final boolean isPolynomial(IAST variables)
```
    Test if this expression is a polynomial for the given list of variables.
    Note: if the list contains no argument, this method returns true for a Symbol expression.
    
    Specified by:
    
    isPolynomial in interface IExpr
    
    Parameters:
    
    variables - a list of variables or an empty list
    
    Returns:
    
    true if this expression is a polynomial; falseotherwise
  - isPolynomial
```
public final boolean isPolynomial(ISymbol variable)
```
    Test if this expression is a polynomial for the given variable.
    Note: if the variable is set to null, this method returns true for a Symbol expression.
    
    Specified by:
    
    isPolynomial in interface IExpr
  - isPolynomialOfMaxDegree
```
public final boolean isPolynomialOfMaxDegree(IAST variables,
                                             long maxDegree)
```
  - isPolynomialOfMaxDegree
```
public final boolean isPolynomialOfMaxDegree(ISymbol variable,
                                             long maxDegree)
```
    Test if this expression is a polynomial of maxDegree (i.e. the maximum exponent <= maxDegree) for the given variable.
    
    Specified by:
    
    isPolynomialOfMaxDegree in interface IExpr
    
    maxDegree - the maximum degree of the polynomial; maxDegree must be greater 0
  - isPositive
```
public final boolean isPositive()
```
    Test if this object is a positive signed number. For an IAST object the method checks, if it is a numeric constant. If the IAST object evaluates to a positive numeric expression this method returns true.
    
    Specified by:
    
    isPositive in interface IExpr
    
    Returns:
    
    true, if this > 0; false in all other case.
  - isPositiveResult
```
public final boolean isPositiveResult()
```
    Test if this expression has a positive result (i.e. greater than 0).
    
    Specified by:
    
    isPositiveResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a positive function or value.
    
    See Also:
    
    #isRealFunction
  - isPower
```
public final boolean isPower()
```
    Test if this expression is the function Power[<arg1>, <arg2>]
    
    Specified by:
    
    isPower in interface IAST
    
    Specified by:
    
    isPower in interface IExpr
  - isRationalResult
```
public final boolean isRationalResult()
```
    Test if this expression is a rational function (i.e. a number, a symbolic constant or an rational function where all arguments are also "rational functions")
    
    Specified by:
    
    isRationalResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a rational function or value.
    
    See Also:
    
    #isRealFunction
  - isRealResult
```
public final boolean isRealResult()
```
    Test if this expression is a real function (i.e. a number, a symbolic constant or an integer function where all arguments are also "reals functions")
    
    Specified by:
    
    isRealResult in interface IExpr
    
    Returns:
    
    true, if the given expression is a real function or value.
    
    See Also:
    
    IExpr.isIntegerResult()
  - isRuleAST
```
public final boolean isRuleAST()
```
    Test if this expression is of the form Rule[<arg1>, <arg2>] or RuleDelayed[<arg1>, <arg2>].
    
    Specified by:
    
    isRuleAST in interface IExpr
  - isSame
```
public final boolean isSame(IExpr expression)
```
    Test if this expression equals the given expression. If the compared expressions are of the same numeric type, they are equal to a given EPSILON
    
    Specified by:
    
    isSame in interface IExpr
  - isSame
```
public final boolean isSame(IExpr expression,
                            double epsilon)
```
    Test if this expression equals the given expression. If the compared expressions are of the same numeric type, they are equal to a given EPSILON
    
    Specified by:
    
    isSame in interface IExpr
  - isSameHead
```
public boolean isSameHead(IExpr head)
```
    Check if the object at index 0 (i.e. the head of the list) is the same object as head
    
    Parameters:
    
    head - object to compare with element at location 0
    
    Returns:
  - isSameHead
```
public boolean isSameHead(IExpr head,
                          int length)
```
    Check if the object at index 0 (i.e. the head of the list) is the same object as head and if the size of the list equals length.
    
    Parameters:
    
    head - object to compare with element at location 0
    
    length -
    
    Returns:
  - isSameHead
```
public boolean isSameHead(IExpr head,
                          int minLength,
                          int maxLength)
```
    Check if the object at index 0 (i.e. the head of the list) is the same object as head and if the size of the list is between minLength and maxLength.
    
    Parameters:
    
    head - object to compare with element at location 0
    
    minLength - minimum length of list elements.
    
    maxLength - maximum length of list elements.
    
    Returns:
  - isSameHeadSizeGE
```
public boolean isSameHeadSizeGE(IExpr head,
                                int length)
```
    Check if the object at index 0 (i.e. the head of the list) is the same object as head and if the size of the list is greater or equal length.
    
    Parameters:
    
    head - object to compare with element at location 0
    
    length -
    
    Returns:
  - isSequence
```
public final boolean isSequence()
```
    Test if this expression is a sequence (i.e. an AST with head Sequence)
    
    Specified by:
    
    isSequence in interface IExpr
  - isSignedNumber
```
public final boolean isSignedNumber()
```
    Test if this expression is a signed number. I.e. an instance of type ISignedNumber.
    
    Specified by:
    
    isSignedNumber in interface IExpr
  - isSin
```
public final boolean isSin()
```
    Test if this expression is the function Sin[<arg>]
    
    Specified by:
    
    isSin in interface IExpr
  - isSinh
```
public final boolean isSinh()
```
    Test if this expression is the function Sinh[<arg>]
    
    Specified by:
    
    isSinh in interface IExpr
  - isSlot
```
public final boolean isSlot()
```
    Test if this expression is the function Slot[<integer-value>]
    
    Specified by:
    
    isSlot in interface IExpr
  - isSlotSequence
```
public final boolean isSlotSequence()
```
    Test if this expression is the function SlotSequence[<integer-value>]
    
    Specified by:
    
    isSlotSequence in interface IExpr
  - isSpan
```
public final boolean isSpan()
```
    Specified by:
    
    isSpan in interface IExpr
  - isTan
```
public final boolean isTan()
```
    Test if this expression is the function TAn[<arg>]
    
    Specified by:
    
    isTan in interface IExpr
  - isTanh
```
public final boolean isTanh()
```
    Test if this expression is the function Tanh[<arg>]
    
    Specified by:
    
    isTanh in interface IExpr
  - isTimes
```
public final boolean isTimes()
```
    Test if this expression is the multiplication function Times[<arg1>, <arg2>, ...]
    
    Specified by:
    
    isTimes in interface IAST
    
    Specified by:
    
    isTimes in interface IExpr
  - isUnit
```
public final boolean isUnit()
```
    Test if this is a unit. I.e. there exists x with this.multiply(x).isONE() == true.
    
    Specified by:
    
    isUnit in interface edu.jas.structure.MonoidElem<IExpr>
    
    Specified by:
    
    isUnit in interface IExpr
    
    Returns:
    
    true if this is a unit, else false.
  - isValue
```
public final boolean isValue()
```
    Returns true, if this symbol or ast expression is bound to a value (i.e. the evaluation returns an assigned value).
    
    Specified by:
    
    isValue in interface IExpr
  - isVector
```
public final int isVector()
```
    Test if this expression is a vector and return the dimension of the vector. This expression is only a vector, if the expression is a List(...) and no element is itself a List(...).
    
    Specified by:
    
    isVector in interface IExpr
    
    Returns:
    
    -1 if the expression is no vector or size()-1 of this vector AST.
  - iterator
```
public final java.util.Iterator<IExpr> iterator()
```
    Returns an iterator over the elements in this IAST starting with offset 1.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<IExpr>
    
    Specified by:
    
    iterator in interface java.util.Collection<IExpr>
    
    Specified by:
    
    iterator in interface java.util.List<IExpr>
    
    Specified by:
    
    iterator in interface IAST
    
    Overrides:
    
    iterator in class java.util.AbstractList<IExpr>
    
    Returns:
    
    an iterator over this IASTs argument values from 1..(size-1).
  - iterator0
```
public final java.util.Iterator<IExpr> iterator0()
```
    Description copied from interface: IAST
    
    Returns an iterator over the elements in this list starting with offset 0.
    
    Specified by:
    
    iterator0 in interface IAST
    
    Returns:
    
    an iterator over this list values.
  - last
```
public final IExpr last()
```
    Get the last element of the AST list (i.e. get(size()-1).
    
    Specified by:
    
    last in interface IAST
    
    Returns:
    
    the last argument of the function represented by this AST.
    
    See Also:
    
    IExpr.head()
  - lastIndexOf
```
public final int lastIndexOf(java.lang.Object object)
```
    Specified by:
    
    lastIndexOf in interface java.util.List<IExpr>
    
    Overrides:
    
    lastIndexOf in class java.util.AbstractList<IExpr>
  - leafCount
```
public final long leafCount()
```
    Count the number of leaves of this expression.
    
    Specified by:
    
    leafCount in interface IExpr
    
    Returns:
  - leaves
```
public final java.util.List<IExpr> leaves()
```
    Get a list of the leaf expressions.
    
    Specified by:
    
    leaves in interface IExpr
    
    Returns:
    
    Instances of ExprImpl should return null, while any other expression may not return null (but can return an empty list).
  - map
```
public final IAST map(java.util.function.Function<IExpr,IExpr> function)
```
    Maps the elements of this IAST with the unary functor. If the function returns null the original element is used (i.e. the functor didn't modified this AST).
    
    Example for mapping with Functors#replace1st(), where the first argument will be replaced by the current argument of this AST:
```
 plusAST.map(Functors.replace1st(F.D(null, dAST.arg2())));
 
```
    Specified by:
    
    map in interface IAST
    
    Parameters:
    
    function - a unary function
    
    Returns:
  - map
```
public final IAST map(IAST clonedResultAST,
                      java.util.function.Function<IExpr,IExpr> function)
```
    Maps the elements of this IAST with the unary functor. If the function returns null the original element of the result list is used.
    
    Specified by:
    
    map in interface IAST
    
    Parameters:
    
    clonedResultAST - a list which is cloned from this list or greater or equal in size of this list.
    
    function - a unary function
    
    Returns:
  - map
```
public final IAST map(IAST resultAST,
                      IAST secondAST,
                      java.util.function.BiFunction<IExpr,IExpr,IExpr> function)
```
    Maps the elements of this IAST with the elements of the secondAST.
    
    Specified by:
    
    map in interface IAST
    
    Returns:
    
    the given resultAST.
  - map
```
public final IAST map(IExpr head,
                      java.util.function.Function<IExpr,IExpr> function)
```
    Maps the elements of this IAST with the unary functor. If the function returns null the original element of the result list is used.
    
    Specified by:
    
    map in interface IAST
    
    Parameters:
    
    head - the new head element of the result list
    
    function - a unary function
    
    Returns:
  - mapAt
```
public final IAST mapAt(IAST appendAST,
                        IAST replacement,
                        int position)
```
    Maps the elements of this IAST with the unary functor Functors.replaceArg(replacement, position), there replacement is an IAST at which the argument at the given position will be replaced by the currently mapped element and appends the element to appendAST.
    
    Specified by:
    
    mapAt in interface IAST
    
    replacement - an IAST there the argument at the given position is replaced by the currently mapped argument of this IAST.
    
    Returns:
    
    appendAST
    
    See Also:
    
    IAST.map(Function)
  - mapAt
```
public final IAST mapAt(IAST replacement,
                        int position)
```
    Maps the elements of this IAST with the unary functor Functors.replaceArg(replacement, position), there replacement is an IAST at which the argument at the given position will be replaced by the currently mapped element.
    
    Example for mapping with Functors#replaceArg(), where the argument at the given position will be replaced by the current argument of this AST:
```
 plusAST.mapAt(F.D(null, F.x), 1);
 
```
    Specified by:
    
    mapAt in interface IAST
    
    Parameters:
    
    replacement - an IAST there the argument at the given position is replaced by the currently mapped argument of this IAST.
    
    Returns:
    
    See Also:
    
    IAST.map(Function)
  - minus
```
public final IExpr minus(IExpr that)
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (this - that). Calculates F.eval(F.Plus(this, F.Times(F.CN1, that))) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    minus in interface IExpr
    
    Returns:
  - mod
```
public final IExpr mod(IExpr that)
```
    Specified by:
    
    mod in interface IExpr
  - multiply
```
public final IExpr multiply(IExpr that)
```
    Additional multiply method which works like times() to fulfill groovy's method signature
    
    Specified by:
    
    multiply in interface edu.jas.structure.MonoidElem<IExpr>
    
    Specified by:
    
    multiply in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    multiply in interface IExpr
    
    Parameters:
    
    that - element to multiply
    
    Returns:
    
    this * S.
    
    See Also:
    
    IExpr.times(IExpr)
  - negate
```
public final IExpr negate()
```
    Negate this.
    
    Specified by:
    
    negate in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Specified by:
    
    negate in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Returns:
    
    - this.
  - negative
```
public final IExpr negative()
```
    Additional negative method, which works like opposite to fulfill groovy's method signature
    
    Specified by:
    
    negative in interface IExpr
    
    Returns:
    
    See Also:
    
    IExpr.opposite()
  - opposite
```
public final IExpr opposite()
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (-1) * this. Calculates F.eval(F.Times(F.CN1, this)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    opposite in interface IExpr
    
    Returns:
    
    See Also:
    
    IExpr.negative()
  - optional
```
public final IExpr optional(IExpr that)
```
    The ExprNull.NIL#optional() method always returns that. All other objects which implement this method returns that if that!=null or this if that==null
    
    Specified by:
    
    optional in interface IExpr
    
    Returns:
    
    that if that!=null or this in all other cases.
    
    See Also:
    
    optional(IExpr)
  - or
```
public final IExpr or(IExpr that)
```
    Specified by:
    
    or in interface IExpr
  - patternHashCode
```
public final int patternHashCode()
```
    Calculate a special hash value to find a matching rule in a hash table
    
    Specified by:
    
    patternHashCode in interface IAST
    
    Returns:
  - plus
```
public final IExpr plus(IExpr that)
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (this + that). Calculates F.eval(F.Plus(this, that)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    plus in interface IExpr
    
    Returns:
  - power
```
public final IExpr power(IExpr that)
```
    Returns an IExpr whose value is (this ^ that). Calculates F.eval(F.Power(this, that)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    power in interface IExpr
    
    Returns:
    
    (this ^ that)
  - power
```
public final IExpr power(long n)
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (this ^ n). Calculates F.eval(F.Power(this, that)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    power in interface IExpr
    
    Returns:
    
    (this ^ n)
  - prependClone
```
public final IAST prependClone(IExpr expr)
```
    Prepend an expression to this list.
    
    Specified by:
    
    prependClone in interface IAST
    
    Returns:
    
    this after prepending the given expression.
  - range
```
public final ASTRange range()
```
    Get the range of elements [0..sizeOfAST[ of the AST
    
    Specified by:
    
    range in interface IAST
    
    Returns:
  - range
```
public final ASTRange range(int start)
```
    Get the range of elements [start..sizeOfAST[ of the AST
    
    Specified by:
    
    range in interface IAST
    
    Returns:
  - range
```
public final ASTRange range(int start,
                            int end)
```
    Get the range of elements [start..end[ of the AST
    
    Specified by:
    
    range in interface IAST
    
    Returns:
  - remainder
```
public final IExpr remainder(IExpr that)
```
    Description copied from interface: edu.jas.structure.MonoidElem
    
    Remainder after division of this by S.
    
    Specified by:
    
    remainder in interface edu.jas.structure.MonoidElem<IExpr>
    
    Returns:
    
    this - (this / S) * S.
  - removeAtClone
```
public final IAST removeAtClone(int position)
```
    Create a shallow copy of this IAST instance (the elements themselves are not copied) and remove the element at the given position.
    
    Specified by:
    
    removeAtClone in interface IAST
    
    Returns:
    
    a clone with removed element at the given position.
  - replaceAll
```
public final IExpr replaceAll(java.util.function.Function<IExpr,IExpr> function)
```
    Replace all (sub-) expressions with the given unary function. If no substitution matches, the method returns null.
    
    Specified by:
    
    replaceAll in interface IExpr
    
    Parameters:
    
    function - if the unary functions apply() method returns F.NIL the expression isn't substituted.
    
    Returns:
    
    F.NIL if no substitution of a (sub-)expression was possible.
  - replaceAll
```
public final IExpr replaceAll(IAST astRules)
```
    Replace all (sub-) expressions with the given rule set. If no substitution matches, the method returns null.
    
    Specified by:
    
    replaceAll in interface IExpr
    
    Parameters:
    
    astRules - rules of the form x->y or {a->b, c->d}; the left-hand-side of the rule can contain pattern objects.
    
    Returns:
    
    F.NIL if no substitution of a (sub-)expression was possible.
  - replacePart
```
public final IExpr replacePart(IAST astRules)
```
    Replace all subexpressions with the given rule set. A rule must contain the position of the subexpression which should be replaced on the left-hand-side. If no substitution matches, the method returns F.NIL.
    
    Specified by:
    
    replacePart in interface IExpr
    
    Parameters:
    
    astRules - rules of the form position->y or {position1->b, position2->d}
    
    Returns:
    
    F.NIL if no substitution of a subexpression was possible.
  - replaceRepeated
```
public final IExpr replaceRepeated(java.util.function.Function<IExpr,IExpr> function)
```
    Repeatedly replace all (sub-) expressions with the given unary function. If no substitution matches, the method returns this.
    
    Specified by:
    
    replaceRepeated in interface IExpr
    
    Parameters:
    
    function - if the unary functions apply() method returns null the expression isn't substituted.
    
    Returns:
    
    this if no substitution of a (sub-)expression was possible.
  - replaceRepeated
```
public final IExpr replaceRepeated(IAST astRules)
```
    Repeatedly replace all (sub-) expressions with the given rule set. If no substitution matches, the method returns this.
    
    Specified by:
    
    replaceRepeated in interface IExpr
    
    Parameters:
    
    astRules - rules of the form x->y or {a->b, c->d}; the left-hand-side of the rule can contain pattern objects.
    
    Returns:
    
    this if no substitution of a (sub-)expression was possible.
  - replaceSlots
```
public final IExpr replaceSlots(IAST astSlots)
```
    Description copied from interface: IExpr
    
    Replace all occurrences of Slot[<index>] expressions with the expression at the appropriate index in the given slotsList.
    
    Note: If a slot value is null the Slot will not be substituted.
    
    Specified by:
    
    replaceSlots in interface IExpr
    
    Parameters:
    
    astSlots - the values for the slots.
    
    Returns:
    
    null if no substitution occurred.
  - setAtClone
```
public final IAST setAtClone(int position,
                             IExpr expr)
```
    Create a shallow copy of this IAST instance (the elements themselves are not copied) and set the expr at the given position.
    
    Specified by:
    
    setAtClone in interface IAST
    
    Returns:
    
    a clone with element set to expr at the given position.
  - setEvalFlags
```
public final void setEvalFlags(int i)
```
    Set the evaluation flags for this list.
    
    Specified by:
    
    setEvalFlags in interface IAST
  - signum
```
@Deprecated
public final int signum()
```
    Deprecated.
    
    Signum functionality is used in JAS toString() method, don't use it as math signum function.
    
    Specified by:
    
    signum in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Specified by:
    
    signum in interface IExpr
    
    Returns:
    
    the sign of this.
  - size
```
public int size()
```
    Returns the number of elements in this ArrayList.
    
    Specified by:
    
    size in interface java.util.Collection<IExpr>
    
    Specified by:
    
    size in interface java.util.List<IExpr>
    
    Specified by:
    
    size in class java.util.AbstractCollection<IExpr>
    
    Returns:
    
    the number of elements in this ArrayList.
  - subtract
```
public final IExpr subtract(IExpr that)
```
    Description copied from interface: edu.jas.structure.AbelianGroupElem
    
    Subtract S from this.
    
    Specified by:
    
    subtract in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Specified by:
    
    subtract in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    subtract in interface IExpr
    
    Parameters:
    
    that - element to subtract
    
    Returns:
    
    this - S.
  - sum
```
public final IExpr sum(IExpr that)
```
    Description copied from interface: edu.jas.structure.AbelianGroupElem
    
    Sum of this and S.
    
    Specified by:
    
    sum in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Specified by:
    
    sum in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    sum in interface IExpr
    
    Parameters:
    
    that - element to add
    
    Returns:
    
    this + S.
  - times
```
public final IExpr times(IExpr that)
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (this * that). Calculates F.eval(F.Times(this, that)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    times in interface IExpr
    
    Parameters:
    
    that - the multiplier expression
    
    Returns:
    
    (this * that)
  - timesDistributed
```
public final IExpr timesDistributed(IExpr that)
```
    Description copied from interface: IExpr
    
    Returns an IExpr whose value is (this * that). Calculates F.eval(F.Times(this, that)) in the common case and uses a specialized implementation for derived number classes.
    
    Specified by:
    
    timesDistributed in interface IExpr
    
    Parameters:
    
    that - the multiplier expression
    
    Returns:
    
    (this * that)
  - topHead
```
public final ISymbol topHead()
```
    Returns the ISymbol of the IAST. If the head itself is a IAST it will recursively call head().
    
    Specified by:
    
    topHead in interface IAST
    
    Specified by:
    
    topHead in interface IExpr
    
    Returns:
    
    the 'highest level' head of the expression.
  - toScript
```
public final java.lang.String toScript()
```
    Description copied from interface: edu.jas.structure.Element
    
    Get a scripting compatible string representation.
    
    Specified by:
    
    toScript in interface edu.jas.structure.Element<IExpr>
    
    Returns:
    
    script compatible representation for this Element.
  - toScriptFactory
```
public final java.lang.String toScriptFactory()
```
    Description copied from interface: edu.jas.structure.Element
    
    Get a scripting compatible string representation of the factory.
    
    Specified by:
    
    toScriptFactory in interface edu.jas.structure.Element<IExpr>
    
    Returns:
    
    script compatible representation for this ElemFactory.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.util.AbstractCollection<IExpr>
  - variables2Slots
```
public final IExpr variables2Slots(java.util.Map<IExpr,IExpr> map,
                                   java.util.Collection<IExpr> variableCollector)
```
    Convert the variables (i.e. expressions of type ISymbol which aren't constants) in this expression into Slot[] s.
    
    Specified by:
    
    variables2Slots in interface IExpr
    
    Parameters:
    
    map - for every given symbol argument return the associated unique slot from this map
    
    variableCollector - collects the variables which are used in the replacement process
    
    Returns:
    
    F.NIL if no variable symbol was found.

Class AbstractAST

Nested Class Summary

Nested classes/interfaces inherited from interface org.matheclipse.core.interfaces.IAST

Field Summary

Fields inherited from class java.util.AbstractList

Fields inherited from interface org.matheclipse.core.interfaces.IAST

Fields inherited from interface org.matheclipse.core.interfaces.IExpr

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractList

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface org.matheclipse.core.interfaces.IAST

Methods inherited from interface org.matheclipse.core.interfaces.IExpr

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Field Detail

fEvalFlags

hashValue

Constructor Detail

AbstractAST

Method Detail

$div

$minus

$plus

$times

$up

abs

accept

accept

accept

accept

addAtClone

addEvalFlags

and

appendClone

apply

apply

apply

apply

apply

args

asType

clearHashCache

clone

compareTo

contains

copy

copyFrom

copyHead

copyUntil

copyUntil

dec

divide

egcd

equals

equalsAt

equalsFromPosition

evalComplex

evalDouble

evalNumber

evalSignedNumber

evaluate

factory

filter

filter

filter

filter

filter

filter

filter

findFirstEquals

forEach

fullFormString

gcd

get

getAST

getAt

getEvalFlags

getHashCache