IExpr

All Superinterfaces:: edu.jas.structure.AbelianGroupElem<IExpr>, java.lang.Comparable<IExpr>, edu.jas.structure.Element<IExpr>, org.apache.commons.math4.FieldElement<IExpr>, edu.jas.structure.GcdRingElem<IExpr>, edu.jas.structure.MonoidElem<IExpr>, edu.jas.structure.RingElem<IExpr>, java.io.Serializable

All Known Subinterfaces:: IAST, IBigNumber, IComplex, IComplexNum, IFraction, IInteger, INum, INumber, IPattern, IPatternObject, IPatternSequence, IRational, ISignedNumber, IStringX, ISymbol

All Known Implementing Classes:: AbstractAST, AbstractFractionSym, AbstractIntegerSym, ApcomplexNum, ApfloatNum, AST, AST0, AST1, AST2, AST3, BigFractionSym, BigIntegerSym, Blank, ComplexNum, ComplexSym, ExprID, ExprImpl, FractionSym, HMArrayList, IntegerSym, MethodSymbol, NILPointer, Num, NumStr, Pattern, PatternSequence, StringX, Symbol

public interface IExpr
extends java.lang.Comparable<IExpr>, edu.jas.structure.GcdRingElem<IExpr>, java.io.Serializable, org.apache.commons.math4.FieldElement<IExpr>

(I)nterface for a mathematical (Expr)ession
IExpr is the main interface for the Symja object type hierarchy:

 java.lang.Object
    |--- java.util.AbstractCollection
    |       |--- java.util.AbstractList
    |               |--- org.matheclipse.core.expression.HMArrayList
    |                       |--- org.matheclipse.core.expression.AST - abstract syntax tree which represents lists, vectors, matrices and functions
    |                                           implements IAST, List, IExpr
    |
    |--- org.matheclipse.core.expression.ExprImpl 
            |           implements IExpr
            |
            |--- org.matheclipse.core.expression.ApcomplexNum - Apcomplex number
            |                   implements IComplexNum, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.ApfloatNum - Apfloat number
            |                   implements INum, ISignedNumber, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.ComplexNum - a complex number with real and imaginary part represented by Java double
            |                   implements IComplexNum, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.ComplexSym - exact complex number
            |                   implements IComplex, IBigNumber, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.FractionSym - exact fraction number
            |                   implements IFraction, IRational, ISignedNumber, IBigNumber, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.IntegerSym - exact integer number 
            |                   implements IInteger, IRational, ISignedNumber, IBigNumber, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.Num - a real number which is represented by a Java double value
            |                   implements INum, ISignedNumber, INumber, IExpr
            |
            |--- org.matheclipse.core.expression.Pattern - a pattern object (i.e. x_)
            |                   implements IPattern, IPatternObject, IExpr
            |
            |--- org.matheclipse.core.expression.PatternSequence - a pattern sequence object (i.e. x__)
            |                   implements IPatternSequence, IPatternObject, IExpr
            |
            |--- org.matheclipse.core.expression.StringX - a Java string wrapper
            |                   implements IStringX, IExpr
            |
            |--- org.matheclipse.core.expression.Symbol - represents variables, function names or constants
                                implements ISymbol, IExpr

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ASTID`
`static int`	`BLANKID`
`static int`	`COMPLEXID`
`static int`	`DOUBLECOMPLEXID`
`static int`	`DOUBLEID`
`static int`	`FRACTIONID`
`static int`	`INTEGERID`
`static int`	`METHODSYMBOLID`
`static int`	`PATTERNID`
`static int`	`STRINGID`
`static int`	`SYMBOLID`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default 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 `^`.
`<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`
`IExpr`	`and(IExpr that)`
`IExpr`	`apply(IExpr... leaves)`
`IExpr`	`apply(java.util.List<? extends IExpr> leaves)`
`java.lang.Object`	`asType(java.lang.Class<?> clazz)`
`int`	`compareTo(IExpr obj)` Compares this expression with the specified expression for order.
`IExpr`	`dec()` Returns an `IExpr` whose value is `(this - 1)`.
`IExpr`	`divide(IExpr that)` Returns an `IExpr` whose value is `(this / that)`.
`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.
`default IExpr`	`evaluate(EvalEngine engine)` Evaluate an expression
`default IExpr`	`evaluateHead(IAST ast, EvalEngine engine)`
`java.lang.String`	`fullFormString()` Return the `FullForm()` of this expression
`IExpr`	`getAt(int index)` Get the element at the specified `index` if this object is of type `IAST`.
`default org.apache.commons.math4.Field<IExpr>`	`getField()` Get the `Field` to which the instance belongs.
`IExpr`	`head()` If this object is an instance of `IAST` get the first element (offset 0) of the `IAST` list (i.e. get(0) ).
`int`	`hierarchy()` A unique integer ID for the implementation of this expression
`default void`	`ifPresent(java.util.function.Consumer<? super IExpr> consumer)` If this expression unequals `F.NIL`, invoke the specified consumer with the `this` object, otherwise do nothing.
`IExpr`	`inc()` Returns an `IExpr` whose value is `(this + 1)`.
`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.
`default boolean`	`isAllExpanded()` Test if this expression and all subexpressions are already expanded i.e.
`default boolean`	`isAnd()` Test if this expression is the function `And[<arg>,...]`
`default boolean`	`isArcCos()` Test if this expression is the function `ArcCos[<arg>]`
`default boolean`	`isArcCosh()` Test if this expression is the function `ArcCosh[<arg>]`
`default boolean`	`isArcSin()` Test if this expression is the function `ArcSin[<arg>]`
`default boolean`	`isArcSinh()` Test if this expression is the function `ArcSinh[<arg>]`
`default boolean`	`isArcTan()` Test if this expression is the function `ArcTan[<arg>]`
`default boolean`	`isArcTanh()` Test if this expression is the function `ArcTanh[<arg>]`
`default 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`.
`default 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..`
`default 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..`
`default 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..`
`default 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..`
`default 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..`
`default 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..`
`default 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`.
`default boolean`	`isAtom()` Test if this expression is an atomic expression (i.e. no AST expression)
`default boolean`	`isBlank()` Test if this expression is a `Blank[]` object
`default boolean`	`isComplex()` Test if this expression is a symbolic complex number (i.e.
`default boolean`	`isComplexInfinity()` Test if this expression is representing ComplexInfinity (i.e.
`default boolean`	`isComplexNumeric()` Test if this expression is a numeric complex number (i.e.
`default boolean`	`isCondition()` Test if this expression is the Condition function `Condition[<arg1>, <arg2>]`
`default boolean`	`isConstant()` Test if this expression is a symbol with attribute `Constant`.
`default boolean`	`isCos()` Test if this expression is the function `Cos[<arg>]`
`default boolean`	`isCosh()` Test if this expression is the function `Cosh[<arg>]`
`default IAST[]`	`isDerivative()` Test if this expression is a `Derivative[number,...]`
`default boolean`	`isDirectedInfinity()` Test if this expression is representing a DirectedInfinity (i.e.
`default boolean`	`isE()` Test if this expression equals `E` (base of the natural logarithm; approximately equal to 2.71828...) in symbolic or numeric mode.
`default boolean`	`isExpanded()` Test if this expression is already expanded i.e.
`default boolean`	`isFalse()` Test if this expression equals the symbol "False"
`default 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..`
`default boolean`	`isFraction()` Test if this expression is a fractional number, but no integer number.
`default boolean`	`isFree(IExpr pattern)` Returns `true`, if all of the elements in the subexpressions or the expression itself, did not match the given pattern.
`default 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.
`default 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.
`default 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.
`default 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.
`default boolean`	`isFreeOfPatterns()` Returns `true`, if all of the elements in the subexpressions or the expression itself, are no pattern objects.
`default boolean`	`isFunction()` Test if this expression is a `Function( arg1 )` expression with at least 1 argument.
`default boolean`	`isGEOrdered(IExpr expr)` Compares this expression with the specified expression for order.
`default boolean`	`isGTOrdered(IExpr expr)` Compares this expression with the specified expression for order.
`default boolean`	`isIndeterminate()` Test if this expression is representing `Indeterminate`
`default boolean`	`isInfinity()` Test if this expression is representing `Infinity` (i.e.
`default boolean`	`isInteger()` Test if this expression is a integer number
`default 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")
`default boolean`	`isLEOrdered(IExpr obj)` Compares this expression with the specified expression for order.
`default boolean`	`isList()` Test if this expression is a list (i.e. an AST with head List)
`default boolean`	`isListOfLists()` Test if this expression is a list of lists
`default boolean`	`isLog()` Test if this expression is the function `Log[<arg>]`
`default boolean`	`isLTOrdered(IExpr expr)` Compares this expression with the specified expression for order.
`default int[]`	`isMatrix()` Test if this expression is a matrix and return the dimensions as array [row-dimension, column-dimension].
`default boolean`	`isMember(IExpr pattern, boolean heads)` Returns `true`, if at least one of the elements in the subexpressions or the expression itself, match the given pattern.
`default 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.
`default boolean`	`isMinusOne()` Test if this expression equals `-1` in symbolic or numeric mode.
`default boolean`	`isModule()` Test if this expression is the Module function `Module[<arg1>, <arg2>]`
`default boolean`	`isNegative()` Test if this object is a negative signed number.
`default boolean`	`isNegativeInfinity()` Test if this expression is representing `-Infinity` (i.e.
`default boolean`	`isNegativeResult()` Test if this expression has a negative result (i.e. less than 0).
`default boolean`	`isNonNegativeResult()` Test if this expression has a non-negative result (i.e. greater equal 0).
`default boolean`	`isNot()` Test if this expression is the function `Not[<arg>]`
`default boolean`	`isNumber()` Test if this expression is a number.
`default boolean`	`isNumEqualInteger(IInteger value)` Check if this expression equals an `IInteger` value.
`default boolean`	`isNumEqualRational(IRational value)` Check if this expression equals an `IRational` value.
`default boolean`	`isNumeric()` Test if this expression is a numeric number (i.e. an instance of type `INum` or type `IComplexNum`.
`default 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")
`default boolean`	`isNumericMode()` Test if this expression contains a numeric number (i.e. of type `INum` or `IComplexNum`.
`default boolean`	`isNumIntValue()` Check if this expression represents an `int` value.
`default boolean`	`isOne()` Test if this expression equals `1` in symbolic or numeric mode.
`default boolean`	`isONE()` Deprecated. use `isOne()` instead.
`default boolean`	`isOr()` Test if this expression is the function `Or[<arg>,...]`
`default 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`.
`default boolean`	`isPattern()` Test if this expression is a `Pattern[symbol]` object
`default boolean`	`isPatternDefault()` Return `true`, if the expression is a pattern object with an associated default value (for example `0` is the default value for the addition expression `x_+y_.`
`default boolean`	`isPatternExpr()` Test if this expression or a subexpression is a pattern object.
`default boolean`	`isPatternSequence()` Test if this expression is a pattern sequence object
`default boolean`	`isPi()` Test if this expression equals `Pi` (the ratio of a circle's circumference to its diameter, approx. 3.141592...) in symbolic or numeric mode.
`default boolean`	`isPlus()` Test if this expression is the addition function `Plus[<arg1>, <arg2>, ...]`
`default boolean`	`isPlusTimesPower()` Test if this expression is a `Plus, Power or Times` function.
`default boolean`	`isPolynomial(IAST variables)` Test if this expression is a polynomial for the given list of `variables`.
`default boolean`	`isPolynomial(ISymbol variable)` Test if this expression is a polynomial for the given `variable`.
`default boolean`	`isPolynomialOfMaxDegree(ISymbol variable, long maxDegree)` Test if this expression is a polynomial of `maxDegree` (i.e.
`default boolean`	`isPositive()` Test if this object is a positive signed number.
`default boolean`	`isPositiveResult()` Test if this expression has a positive result (i.e. greater than 0).
`default boolean`	`isPower()` Test if this expression is the function `Power[<arg1>, <arg2>]`
`default boolean`	`isPresent()` Return `true` if this expression unequals `F.NIL`, otherwise `false`.
`default boolean`	`isRational()` Test if this expression is a rational number, i.e. integer or fraction number.
`default 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")
`default boolean`	`isRationalValue(IRational value)` Test if this expression equals `value` in symbolic or numeric mode.
`default 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")
`default boolean`	`isRuleAST()` Test if this expression is of the form `Rule[<arg1>, <arg2>]` or `RuleDelayed[<arg1>, <arg2>]`.
`default boolean`	`isSame(IExpr expression)` Test if this expression equals the given expression.
`default boolean`	`isSame(IExpr expression, double epsilon)` Test if this expression equals the given expression.
`default boolean`	`isSequence()` Test if this expression is a sequence (i.e. an AST with head Sequence)
`default boolean`	`isSignedNumber()` Test if this expression is a signed number.
`default boolean`	`isSin()` Test if this expression is the function `Sin[<arg>]`
`default boolean`	`isSinh()` Test if this expression is the function `Sinh[<arg>]`
`default boolean`	`isSlot()` Test if this expression is the function `Slot[<integer-value>]`
`default boolean`	`isSlotSequence()` Test if this expression is the function `SlotSequence[<integer-value>]`
`default boolean`	`isSpan()`
`default boolean`	`isSymbol()` Test if this expression is a symbol
`default boolean`	`isTan()` Test if this expression is the function `TAn[<arg>]`
`default boolean`	`isTanh()` Test if this expression is the function `Tanh[<arg>]`
`default boolean`	`isTimes()` Test if this expression is the multiplication function `Times[<arg1>, <arg2>, ...]`
`default boolean`	`isTrue()` Test if this expression equals the symbol `True`.
`default boolean`	`isUnit()` Test if this is a unit.
`default boolean`	`isValue()` Returns `true`, if this symbol or ast expression is bound to a value (i.e. the evaluation returns an assigned value).
`default boolean`	`isVariable()` Test if this expression is a symbol which doesn't has attribute `Constant`.
`default int`	`isVector()` Test if this expression is a vector and return the dimension of the vector.
`default boolean`	`isZero()` Test if this expression equals `0` in symbolic or numeric mode.
`default boolean`	`isZERO()` Deprecated. use `isZero()` instead.
`long`	`leafCount()` Count the number of leaves of this expression.
`java.util.List<IExpr>`	`leaves()` Get a list of the leaf expressions.
`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
`default IExpr`	`multiply(int n)` Compute n × this.
`IExpr`	`negative()` Additional negative method, which works like opposite to fulfill groovy's method signature
`static IExpr`	`ofNullable(IExpr value)` Returns an `IExpr` describing the specified value, if non-null, otherwise returns `F.NIL` .
`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)`
`default IExpr`	`orElse(IExpr other)` Return `this` if `this` unequals `F.NIL` , otherwise return `other`. .
`default IExpr`	`orElseGet(java.util.function.Supplier<? extends IExpr> other)` Return `this` if `this` unequals `F.NIL` , otherwise invoke `other` and return the result of that invocation.
`default <X extends java.lang.Throwable> IExpr`	`orElseThrow(java.util.function.Supplier<? extends X> exceptionSupplier)` Return `this` if `this` unequals `F.NIL` , otherwise throw an exception to be created by the provided supplier.
`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)`.
`default IExpr`	`reciprocal()` Returns the multiplicative inverse of `this` element.
`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 slotsList)` Replace all occurrences of Slot[<index>] expressions with the expression at the appropriate `index` in the given `slotsList`.
`int`	`signum()` Deprecated.
`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)`.
`default IExpr`	`timesDistributed(IExpr that)` Returns an `IExpr` whose value is `(this * that)`.
`ISymbol`	`topHead()` The 'highest level' head of the expression, before Symbol, Integer, Real or String. for example while the head of a[b][c] is a[b], the top head is a.
`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 interface edu.jas.structure.RingElem
egcd, gcd

Methods inherited from interface edu.jas.structure.AbelianGroupElem
abs, negate

Methods inherited from interface edu.jas.structure.MonoidElem
remainder

Methods inherited from interface edu.jas.structure.Element
copy, equals, factory, hashCode, toScript, toScriptFactory

Methods inherited from interface org.apache.commons.math4.FieldElement
negate

- Field Detail
  - ASTID
```
static final int ASTID
```
    See Also:
    
    Constant Field Values
  - BLANKID
```
static final int BLANKID
```
    See Also:
    
    Constant Field Values
  - COMPLEXID
```
static final int COMPLEXID
```
    See Also:
    
    Constant Field Values
  - DOUBLECOMPLEXID
```
static final int DOUBLECOMPLEXID
```
    See Also:
    
    Constant Field Values
  - DOUBLEID
```
static final int DOUBLEID
```
    See Also:
    
    Constant Field Values
  - FRACTIONID
```
static final int FRACTIONID
```
    See Also:
    
    Constant Field Values
  - INTEGERID
```
static final int INTEGERID
```
    See Also:
    
    Constant Field Values
  - METHODSYMBOLID
```
static final int METHODSYMBOLID
```
    See Also:
    
    Constant Field Values
  - PATTERNID
```
static final int PATTERNID
```
    See Also:
    
    Constant Field Values
  - STRINGID
```
static final int STRINGID
```
    See Also:
    
    Constant Field Values
  - SYMBOLID
```
static final int SYMBOLID
```
    See Also:
    
    Constant Field Values
- Method Detail
  - ofNullable
```
static IExpr ofNullable(IExpr value)
```
    Returns an IExpr describing the specified value, if non-null, otherwise returns F.NIL .
    
    Parameters:
    
    value - the possibly-null value to describe
    
    Returns:
    
    an IExpr with a present value if the specified value is non-null, otherwise an empty Optional
  - $div
```
IExpr $div(IExpr that)
```
    Operator overloading for Scala operator /. Calls divide(that).
    
    Parameters:
    
    that -
    
    Returns:
  - $minus
```
IExpr $minus(IExpr that)
```
    Operator overloading for Scala operator /. Calls divide(that).
    
    Parameters:
    
    that -
    
    Returns:
  - $plus
```
IExpr $plus(IExpr that)
```
    Operator overloading for Scala operator +. Calls plus(that).
    
    Parameters:
    
    that -
    
    Returns:
  - $times
```
IExpr $times(IExpr that)
```
    Operator overloading for Scala operator *. Calls times(that).
    
    Parameters:
    
    that -
    
    Returns:
  - $up
```
IExpr $up(IExpr that)
```
    Operator overloading for Scala operator ^. Calls power(that).
    
    Parameters:
    
    that -
    
    Returns:
  - accept
```
<T> T accept(IVisitor<T> visitor)
```
    Accept a visitor with return type T
  - accept
```
boolean accept(IVisitorBoolean visitor)
```
    Accept a visitor with return type boolean
  - accept
```
int accept(IVisitorInt visitor)
```
    Accept a visitor with return type int
    
    Parameters:
    
    visitor -
    
    Returns:
  - accept
```
long accept(IVisitorLong visitor)
```
    Accept a visitor with return type long
    
    Parameters:
    
    visitor -
    
    Returns:
  - and
```
IExpr and(IExpr that)
```
  - apply
```
IExpr apply(IExpr... leaves)
```
    Parameters:
    
    leaves -
    
    Returns:
    
    an IExpr instance with the current expression as head(), and leaves as leaves().
  - apply
```
IExpr apply(java.util.List<? extends IExpr> leaves)
```
    Parameters:
    
    leaves -
    
    Returns:
    
    an IExpr instance with the current expression as head(), and leaves as leaves().
  - asType
```
java.lang.Object asType(java.lang.Class<?> clazz)
```
  - compareTo
```
int compareTo(IExpr obj)
```
    Compares this expression with the specified expression for 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 java.lang.Comparable<IExpr>
    
    Specified by:
    
    compareTo in interface edu.jas.structure.Element<IExpr>
    
    Returns:
    
    0 if this is equal to b, -1 if this is less then b, else +1.
  - dec
```
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.
    
    Returns:
  - divide
```
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 org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    divide in interface edu.jas.structure.MonoidElem<IExpr>
    
    Parameters:
    
    that -
    
    Returns:
  - evalComplex
```
org.apache.commons.math4.complex.Complex evalComplex()
```
    Evaluate the expression to a INumber value.
    
    Returns:
    
    null if the conversion is not possible.
  - evalDouble
```
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.
    
    Returns:
    
    this expression converted to a Java double value.
  - evalNumber
```
INumber evalNumber()
```
    Evaluate the expression to a INumber value.
    
    Returns:
    
    null if the conversion is not possible.
  - evalSignedNumber
```
ISignedNumber evalSignedNumber()
```
    Evaluate the expression to a ISignedNumber value.
    
    Returns:
    
    null if the conversion is not possible.
  - evaluate
```
default IExpr evaluate(EvalEngine engine)
```
    Evaluate an expression
    
    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).
  - evaluateHead
```
default IExpr evaluateHead(IAST ast,
                           EvalEngine engine)
```
  - fullFormString
```
java.lang.String fullFormString()
```
    Return the FullForm() of this expression
  - getAt
```
IExpr getAt(int index)
```
    Get the element at the specified index if this object is of type IAST.
    
    Parameters:
    
    index -
    
    Returns:
  - getField
```
default org.apache.commons.math4.Field<IExpr> getField()
```
    Description copied from interface: org.apache.commons.math4.FieldElement
    
    Get the Field to which the instance belongs.
    
    Specified by:
    
    getField in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Returns:
    
    Field to which the instance belongs
  - head
```
IExpr head()
```
    If this object is an instance of IAST get the first element (offset 0) of the IAST list (i.e. get(0) ).
    
    Returns:
    
    the head of the expression, which must not be null.
  - hierarchy
```
int hierarchy()
```
    A unique integer ID for the implementation of this expression
    
    Returns:
    
    a unique integer id for the implementation of this expression
  - ifPresent
```
default void ifPresent(java.util.function.Consumer<? super IExpr> consumer)
```
    If this expression unequals F.NIL, invoke the specified consumer with the this object, otherwise do nothing.
    
    Parameters:
    
    consumer - block to be executed if this expression unequals F.NIL
    
    See Also:
    
    Optional.ifPresent(Consumer)
  - inc
```
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.
    
    Returns:
  - internalFormString
```
java.lang.String internalFormString(boolean symbolsAsFactoryMethod,
                                    int depth)
```
    Return the internal Java form of this expression.
    
    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
```
java.lang.String internalJavaString(boolean symbolsAsFactoryMethod,
                                    int depth,
                                    boolean useOperators)
```
    Return the internal Java form of this expression.
    
    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
```
java.lang.String internalScalaString(boolean symbolsAsFactoryMethod,
                                     int depth)
```
    Return the internal Scala form of this expression.
    
    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
```
IExpr inverse()
```
    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>
    
    Returns:
    
    ONE / this.
  - isAllExpanded
```
default boolean isAllExpanded()
```
    Test if this expression and all subexpressions are already expanded i.e. all Plus, Times, Power (sub-)expressions are expanded.
  - isAnd
```
default boolean isAnd()
```
    Test if this expression is the function And[<arg>,...]
  - isArcCos
```
default boolean isArcCos()
```
    Test if this expression is the function ArcCos[<arg>]
  - isArcCosh
```
default boolean isArcCosh()
```
    Test if this expression is the function ArcCosh[<arg>]
  - isArcSin
```
default boolean isArcSin()
```
    Test if this expression is the function ArcSin[<arg>]
  - isArcSinh
```
default boolean isArcSinh()
```
    Test if this expression is the function ArcSinh[<arg>]
  - isArcTan
```
default boolean isArcTan()
```
    Test if this expression is the function ArcTan[<arg>]
  - isArcTanh
```
default boolean isArcTanh()
```
    Test if this expression is the function ArcTanh[<arg>]
  - isAST
```
default 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.
    
    See Also:
    
    isAtom()
  - isAST
```
default 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.
    
    See Also:
    
    isAtom()
  - isAST
```
default 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.
    
    Parameters:
    
    header - the header element to chck for
    
    length - the length the AST expression must have
    
    See Also:
    
    isAtom()
  - isAST
```
default 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.
    
    Parameters:
    
    args - the arguments of this AST which should be tested, if they are equal, a null value argument skips the equals chack.
    
    See Also:
    
    isAtom()
  - isAST
```
default 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.
    
    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:
    
    isAtom()
  - isAST
```
default 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].
    
    See Also:
    
    isAtom()
  - isAST
```
default 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].
    
    See Also:
    
    isAtom()
  - isASTSizeGE
```
default 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.
    
    See Also:
    
    isAtom()
  - isAtom
```
default boolean isAtom()
```
    Test if this expression is an atomic expression (i.e. no AST expression)
  - isBlank
```
default boolean isBlank()
```
    Test if this expression is a Blank[] object
  - isComplex
```
default boolean isComplex()
```
    Test if this expression is a symbolic complex number (i.e. instanceof IComplex)
  - isComplexInfinity
```
default boolean isComplexInfinity()
```
    Test if this expression is representing ComplexInfinity (i.e. DirectedInfinity[])
  - isComplexNumeric
```
default boolean isComplexNumeric()
```
    Test if this expression is a numeric complex number (i.e. instanceof IComplexNum)
  - isCondition
```
default boolean isCondition()
```
    Test if this expression is the Condition function Condition[<arg1>, <arg2>]
  - isConstant
```
default boolean isConstant()
```
    Test if this expression is a symbol with attribute Constant. Therefore numbers return false for this method!
    
    See Also:
    
    #isRealFunction(), isNumericFunction()
  - isCos
```
default boolean isCos()
```
    Test if this expression is the function Cos[<arg>]
  - isCosh
```
default boolean isCosh()
```
    Test if this expression is the function Cosh[<arg>]
  - isDerivative
```
default 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.
    Returns:
    
    null if the expression is not a Derivative[number,...][symbol][arg] or Derivative[number,...][symbol] expression.
  - isDirectedInfinity
```
default boolean isDirectedInfinity()
```
    Test if this expression is representing a DirectedInfinity (i.e. Infinity->DirectedInfinity[1], -Infinity->DirectedInfinity[-1], ComplexInfinity->DirectedInfinity[])
  - isE
```
default boolean isE()
```
    Test if this expression equals E (base of the natural logarithm; approximately equal to 2.71828...) in symbolic or numeric mode.
    See e (mathematical constant)
  - isExpanded
```
default boolean isExpanded()
```
    Test if this expression is already expanded i.e. Plus, Times, Power expression is expanded.
  - isFalse
```
default boolean isFalse()
```
    Test if this expression equals the symbol "False"
  - isFlatAST
```
default 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.
    
    See Also:
    
    isAtom()
  - isFraction
```
default boolean isFraction()
```
    Test if this expression is a fractional number, but no integer number.
  - isFree
```
default 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).
    
    Parameters:
    
    pattern - a pattern-matching expression
  - isFree
```
default 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.
    
    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
```
default 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.
    
    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
```
default 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.
    
    Parameters:
    
    pattern - a pattern-matching expression
  - isFreeAST
```
default 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.
    
    Parameters:
    
    pattern - a unary predicate
  - isFreeOfPatterns
```
default boolean isFreeOfPatterns()
```
    Returns true, if all of the elements in the subexpressions or the expression itself, are no pattern objects.
    
    Returns:
    
    true if the expression contains no IPatternObject.
  - isFunction
```
default boolean isFunction()
```
    Test if this expression is a Function( arg1 ) expression with at least 1 argument.
  - isGEOrdered
```
default boolean isGEOrdered(IExpr expr)
```
    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).
    
    Parameters:
    
    expr - an expression to compare with
    
    Returns:
    
    true if this expression is canonical greater than or equal to the specified expression.
  - isGTOrdered
```
default boolean isGTOrdered(IExpr expr)
```
    Compares this expression with the specified expression for order. Returns true if this expression is canonical greater than the specified expression (< relation).
    
    Parameters:
    
    expr - an expression to compare with
    
    Returns:
    
    true if this expression is canonical greater than the specified expression.
  - isIndeterminate
```
default boolean isIndeterminate()
```
    Test if this expression is representing Indeterminate
  - isInfinity
```
default boolean isInfinity()
```
    Test if this expression is representing Infinity (i.e. Infinity->DirectedInfinity[1])
  - isInteger
```
default boolean isInteger()
```
    Test if this expression is a integer number
  - isIntegerResult
```
default 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")
    
    Returns:
    
    true, if the given expression is a integer function or value.
    
    See Also:
    
    #isRealFunction
  - isLEOrdered
```
default boolean isLEOrdered(IExpr obj)
```
    Compares this expression with the specified expression for order. Returns true if this expression is canonical less than or equal to the specified expression (<= relation).
    
    Parameters:
    
    expr - an expression to compare with
    
    Returns:
    
    true if this expression is canonical less than or equal to the specified expression.
  - isList
```
default boolean isList()
```
    Test if this expression is a list (i.e. an AST with head List)
  - isListOfLists
```
default boolean isListOfLists()
```
    Test if this expression is a list of lists
    
    See Also:
    
    isList(), isMatrix(), isVector()
  - isLog
```
default boolean isLog()
```
    Test if this expression is the function Log[<arg>]
  - isLTOrdered
```
default boolean isLTOrdered(IExpr expr)
```
    Compares this expression with the specified expression for order. Returns true if this expression is canonical less than the specified expression (< relation).
    
    Parameters:
    
    expr - an expression to compare with
    
    Returns:
    
    true if this expression is canonical less than the specified expression.
  - isMatrix
```
default 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.
    
    Returns:
    
    null if the expression is not a matrix
  - isMember
```
default boolean isMember(IExpr pattern,
                         boolean heads)
```
    Returns true, if at least one of the elements in the subexpressions or the expression itself, match the given pattern.
    
    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.
  - isMember
```
default 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.
    
    Parameters:
    
    predicate - a unary predicate
    
    heads - if set to false, only the arguments of an IAST should be tested and not the Head[] element.
  - isMinusOne
```
default boolean isMinusOne()
```
    Test if this expression equals -1 in symbolic or numeric mode.
  - isModule
```
default boolean isModule()
```
    Test if this expression is the Module function Module[<arg1>, <arg2>]
  - isNegative
```
default 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.
    
    Returns:
    
    true, if this < 0; false in all other case.
  - isNegativeInfinity
```
default boolean isNegativeInfinity()
```
    Test if this expression is representing -Infinity (i.e. -Infinity->DirectedInfinity[-1])
  - isNegativeResult
```
default boolean isNegativeResult()
```
    Test if this expression has a negative result (i.e. less than 0).
    
    Returns:
    
    true, if the given expression is a negative function or value.
    
    See Also:
    
    #isRealFunction
  - isNonNegativeResult
```
default boolean isNonNegativeResult()
```
    Test if this expression has a non-negative result (i.e. greater equal 0).
    
    Returns:
    
    true, if the given expression is a non-negative function or value.
    
    See Also:
    
    #isRealFunction
  - isNot
```
default boolean isNot()
```
    Test if this expression is the function Not[<arg>]
  - isNumber
```
default boolean isNumber()
```
    Test if this expression is a number. I.e. an instance of type INumber.
  - isNumEqualInteger
```
default boolean isNumEqualInteger(IInteger value)
                           throws java.lang.ArithmeticException
```
    Check if this expression equals an IInteger value. The value of an INum or the value of an IInteger object can be equal to value.
    
    Parameters:
    
    value -
    
    Returns:
    
    Throws:
    
    java.lang.ArithmeticException
  - isNumEqualRational
```
default boolean isNumEqualRational(IRational value)
                            throws java.lang.ArithmeticException
```
    Check if this expression equals an IRational value. The value of an IInteger, IFraction or the value of an INum object can be equal to value.
    
    Parameters:
    
    value -
    
    Returns:
    
    Throws:
    
    java.lang.ArithmeticException
    
    See Also:
    
    isRational()
  - isNumeric
```
default boolean isNumeric()
```
    Test if this expression is a numeric number (i.e. an instance of type INum or type IComplexNum.
  - isNumericFunction
```
default 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")
    
    Returns:
    
    true, if the given expression is a numeric function or value.
    
    See Also:
    
    #isRealFunction
  - isNumericMode
```
default boolean isNumericMode()
```
    Test if this expression contains a numeric number (i.e. of type INum or IComplexNum.
    
    Returns:
    
    true, if the given expression contains numeric number (i.e. of type INum or IComplexNum.
    
    See Also:
    
    #isRealFunction
  - isNumIntValue
```
default boolean isNumIntValue()
```
    Check if this expression represents an int value. The value of an INum object can be an int value.
    
    Returns:
  - isOne
```
default boolean isOne()
```
    Test if this expression equals 1 in symbolic or numeric mode.
  - isONE
```
default boolean isONE()
```
    Deprecated. use isOne() instead.
    
    Test if this is one.
    
    Specified by:
    
    isONE in interface edu.jas.structure.MonoidElem<IExpr>
    
    Returns:
    
    true if this is 1, else false.
  - isOr
```
default boolean isOr()
```
    Test if this expression is the function Or[<arg>,...]
  - isOrderlessAST
```
default 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.
    
    See Also:
    
    isAtom()
  - isPattern
```
default boolean isPattern()
```
    Test if this expression is a Pattern[symbol] object
  - isPatternDefault
```
default boolean isPatternDefault()
```
    Return true, if the expression is a pattern object with an associated default value (for example 0 is the default value for the addition expression x_+y_.)
    
    Returns:
  - isPatternExpr
```
default 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.
  - isPatternSequence
```
default boolean isPatternSequence()
```
    Test if this expression is a pattern sequence object
  - isPi
```
default boolean isPi()
```
    Test if this expression equals Pi (the ratio of a circle's circumference to its diameter, approx. 3.141592...) in symbolic or numeric mode.
    See Pi
  - isPlus
```
default boolean isPlus()
```
    Test if this expression is the addition function Plus[<arg1>, <arg2>, ...]
  - isPlusTimesPower
```
default boolean isPlusTimesPower()
```
    Test if this expression is a Plus, Power or Times function.
  - isPolynomial
```
default 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.
    
    Parameters:
    
    variables - a list of variables or an empty list
    
    Returns:
    
    true if this expression is a polynomial; falseotherwise
  - isPolynomial
```
default 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.
  - isPolynomialOfMaxDegree
```
default 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.
    
    Parameters:
    
    maxDegree - the maximum degree of the polynomial; maxDegree must be greater 0
  - isPositive
```
default 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.
    
    Returns:
    
    true, if this > 0; false in all other case.
  - isPositiveResult
```
default boolean isPositiveResult()
```
    Test if this expression has a positive result (i.e. greater than 0).
    
    Returns:
    
    true, if the given expression is a positive function or value.
    
    See Also:
    
    #isRealFunction
  - isPower
```
default boolean isPower()
```
    Test if this expression is the function Power[<arg1>, <arg2>]
  - isPresent
```
default boolean isPresent()
```
    Return true if this expression unequals F.NIL, otherwise false. This method is similar to java.util.Optional#isPresent().
    
    Returns:
    
    true if the expression unequals F.NIL, otherwise false.
    
    See Also:
    
    Optional.isPresent()
  - isRational
```
default boolean isRational()
```
    Test if this expression is a rational number, i.e. integer or fraction number.
    
    See Also:
    
    #isNumEqualRational()
  - isRationalResult
```
default 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")
    
    Returns:
    
    true, if the given expression is a rational function or value.
    
    See Also:
    
    #isRealFunction
  - isRationalValue
```
default boolean isRationalValue(IRational value)
```
    Test if this expression equals value in symbolic or numeric mode.
  - isRealResult
```
default 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")
    
    Returns:
    
    true, if the given expression is a real function or value.
    
    See Also:
    
    isIntegerResult()
  - isRuleAST
```
default boolean isRuleAST()
```
    Test if this expression is of the form Rule[<arg1>, <arg2>] or RuleDelayed[<arg1>, <arg2>].
  - isSame
```
default 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
  - isSame
```
default 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
  - isSequence
```
default boolean isSequence()
```
    Test if this expression is a sequence (i.e. an AST with head Sequence)
  - isSignedNumber
```
default boolean isSignedNumber()
```
    Test if this expression is a signed number. I.e. an instance of type ISignedNumber.
  - isSin
```
default boolean isSin()
```
    Test if this expression is the function Sin[<arg>]
  - isSinh
```
default boolean isSinh()
```
    Test if this expression is the function Sinh[<arg>]
  - isSlot
```
default boolean isSlot()
```
    Test if this expression is the function Slot[<integer-value>]
  - isSlotSequence
```
default boolean isSlotSequence()
```
    Test if this expression is the function SlotSequence[<integer-value>]
  - isSpan
```
default boolean isSpan()
```
  - isSymbol
```
default boolean isSymbol()
```
    Test if this expression is a symbol
  - isTan
```
default boolean isTan()
```
    Test if this expression is the function TAn[<arg>]
  - isTanh
```
default boolean isTanh()
```
    Test if this expression is the function Tanh[<arg>]
  - isTimes
```
default boolean isTimes()
```
    Test if this expression is the multiplication function Times[<arg1>, <arg2>, ...]
  - isTrue
```
default boolean isTrue()
```
    Test if this expression equals the symbol True.
    
    Returns:
    
    true if the expression equals symbol True and false in all other cases
  - isUnit
```
default 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>
    
    Returns:
    
    true if this is a unit, else false.
  - isValue
```
default boolean isValue()
```
    Returns true, if this symbol or ast expression is bound to a value (i.e. the evaluation returns an assigned value).
  - isVariable
```
default boolean isVariable()
```
    Test if this expression is a symbol which doesn't has attribute Constant.
    
    See Also:
    
    isConstant(), isSymbol()
  - isVector
```
default 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(...).
    
    Returns:
    
    -1 if the expression is no vector or size()-1 of this vector AST.
  - isZero
```
default boolean isZero()
```
    Test if this expression equals 0 in symbolic or numeric mode.
  - isZERO
```
default boolean isZERO()
```
    Deprecated. use isZero() instead.
    
    Test if this is zero.
    
    Specified by:
    
    isZERO in interface edu.jas.structure.AbelianGroupElem<IExpr>
    
    Returns:
    
    true if this is 0, else false.
  - leafCount
```
long leafCount()
```
    Count the number of leaves of this expression.
    
    Returns:
  - leaves
```
java.util.List<IExpr> leaves()
```
    Get a list of the leaf expressions.
    
    Returns:
    
    Instances of ExprImpl should return null, while any other expression may not return null (but can return an empty list).
  - minus
```
IExpr minus(IExpr that)
```
    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.
    
    Parameters:
    
    that -
    
    Returns:
  - mod
```
IExpr mod(IExpr that)
```
  - multiply
```
IExpr multiply(IExpr that)
```
    Additional multiply method which works like times() to fulfill groovy's method signature
    
    Specified by:
    
    multiply in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Specified by:
    
    multiply in interface edu.jas.structure.MonoidElem<IExpr>
    
    Parameters:
    
    that -
    
    Returns:
    
    See Also:
    
    times(IExpr)
  - multiply
```
default IExpr multiply(int n)
```
    Description copied from interface: org.apache.commons.math4.FieldElement
    
    Compute n × this. Multiplication by an integer number is defined as the following sum n × this = ∑_i=1ⁿ this.
    
    Specified by:
    
    multiply in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Parameters:
    
    n - Number of times this must be added to itself.
    
    Returns:
    
    A new element representing n × this.
  - negative
```
IExpr negative()
```
    Additional negative method, which works like opposite to fulfill groovy's method signature
    
    Returns:
    
    See Also:
    
    opposite()
  - opposite
```
IExpr opposite()
```
    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.
    
    Returns:
    
    See Also:
    
    negative()
  - optional
```
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
    
    Parameters:
    
    that -
    
    Returns:
    
    that if that!=null or this in all other cases.
    
    See Also:
    
    AbstractAST.optional(IExpr)
  - or
```
IExpr or(IExpr that)
```
  - orElse
```
default IExpr orElse(IExpr other)
```
    Return this if this unequals F.NIL , otherwise return other. .
    
    Parameters:
    
    that -
    
    Returns:
    
    See Also:
    
    Optional.orElse(Object)
  - orElseGet
```
default IExpr orElseGet(java.util.function.Supplier<? extends IExpr> other)
```
    Return this if this unequals F.NIL , otherwise invoke other and return the result of that invocation.
    
    Parameters:
    
    other - a Supplier whose result is returned if no value is present
    
    Returns:
    
    this if this unequals F.NIL, otherwise the result of other.get()
  - orElseThrow
```
default <X extends java.lang.Throwable> IExpr orElseThrow(java.util.function.Supplier<? extends X> exceptionSupplier)
                                                   throws X extends java.lang.Throwable
```
    Return this if this unequals F.NIL , otherwise throw an exception to be created by the provided supplier.
    
    Type Parameters:
    
    X - Type of the exception to be thrown
    
    Parameters:
    
    exceptionSupplier - The supplier which will return the exception to be thrown
    
    Returns:
    
    this if this unequals F.NIL or throw an exception
    
    Throws:
    
    X - if there is no value present
    
    X extends java.lang.Throwable
  - plus
```
IExpr plus(IExpr that)
```
    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.
    
    Parameters:
    
    that -
    
    Returns:
  - power
```
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.
    
    Parameters:
    
    that -
    
    Returns:
    
    (this ^ that)
  - power
```
IExpr power(long n)
```
    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.
    
    Parameters:
    
    that -
    
    Returns:
    
    (this ^ n)
  - reciprocal
```
default IExpr reciprocal()
                  throws org.apache.commons.math4.exception.MathArithmeticException
```
    Description copied from interface: org.apache.commons.math4.FieldElement
    
    Returns the multiplicative inverse of this element.
    
    Specified by:
    
    reciprocal in interface org.apache.commons.math4.FieldElement<IExpr>
    
    Returns:
    
    the inverse of this.
    
    Throws:
    
    org.apache.commons.math4.exception.MathArithmeticException - if this is zero
  - replaceAll
```
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.
    
    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
```
IExpr replaceAll(IAST astRules)
```
    Replace all (sub-) expressions with the given rule set. If no substitution matches, the method returns null.
    
    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
```
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.
    
    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
```
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.
    
    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
```
IExpr replaceRepeated(IAST astRules)
```
    Repeatedly replace all (sub-) expressions with the given rule set. If no substitution matches, the method returns this.
    
    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
```
IExpr replaceSlots(IAST slotsList)
```
    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.
    
    Parameters:
    
    slotsList - the values for the slots.
    
    Returns:
    
    null if no substitution occurred.
  - signum
```
@Deprecated
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>
    
    Returns:
    
    the sign of this.
  - subtract
```
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>
    
    Parameters:
    
    that - element to subtract
    
    Returns:
    
    this - S.
  - sum
```
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>
    
    Parameters:
    
    that - element to add
    
    Returns:
    
    this + S.
  - times
```
IExpr times(IExpr that)
```
    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.
    
    Parameters:
    
    that - the multiplier expression
    
    Returns:
    
    (this * that)
  - timesDistributed
```
default IExpr timesDistributed(IExpr that)
```
    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.
    
    Parameters:
    
    that - the multiplier expression
    
    Returns:
    
    (this * that)
  - topHead
```
ISymbol topHead()
```
    The 'highest level' head of the expression, before Symbol, Integer, Real or String. for example while the head of a[b][c] is a[b], the top head is a.
    
    Returns:
    
    the 'highest level' head of the expression.
  - variables2Slots
```
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.
    
    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.

Interface IExpr

Field Summary

Method Summary

Methods inherited from interface edu.jas.structure.RingElem

Methods inherited from interface edu.jas.structure.AbelianGroupElem

Methods inherited from interface edu.jas.structure.MonoidElem

Methods inherited from interface edu.jas.structure.Element

Methods inherited from interface org.apache.commons.math4.FieldElement

Field Detail

ASTID

BLANKID

COMPLEXID

DOUBLECOMPLEXID

DOUBLEID

FRACTIONID

INTEGERID

METHODSYMBOLID

PATTERNID

STRINGID

SYMBOLID

Method Detail

ofNullable

$div

$minus

$plus

$times

$up

accept

accept

accept

accept

and

apply

apply

asType

compareTo

dec

divide

evalComplex

evalDouble

evalNumber

evalSignedNumber

evaluate

evaluateHead

fullFormString

getAt

getField

head

hierarchy

ifPresent

inc

internalFormString

internalJavaString

internalScalaString

inverse

isAllExpanded

isAnd

isArcCos

isArcCosh

isArcSin

isArcSinh

isArcTan

isArcTanh

isAST

isAST

isAST

isAST

isAST

isAST

isAST

isASTSizeGE

isAtom

isBlank

isComplex

isComplexInfinity

isComplexNumeric

isCondition

isConstant

isCos

isCosh