IExpr

Documentation of 'org.matheclipse.core.interfaces.IExpr' Java class IExpr

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

All Superinterfaces:

AbelianGroupElem<IExpr>, java.lang.Comparable<IExpr>, Element<IExpr>, MonoidElem<IExpr>, RingElem<IExpr>, java.io.Serializable

All Known Subinterfaces:

IAST, IBigNumber, IComplex, IComplexNum, IFraction, IInteger, INum, INumber, IPattern, IPatternSequence, IRational, ISignedNumber, IStringX, ISymbol

All Known Implementing Classes:

AST, ComplexNum, ComplexSym, ExprImpl, FractionSym, IntegerSym, MethodSymbol, Num, Pattern, PatternSequence, StringX, Symbol
```
public interface IExpr
extends java.lang.Comparable<IExpr>, RingElem<IExpr>, java.io.Serializable
```
(I)nterface for a mathematical (Expr)ession

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ASTID`
`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 Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`<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`
`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`	`evaluate(EvalEngine engine)` Evaluate an expression
`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`.
`IExpr`	`head()` If this object is an instance of `IAST` get the first element (offset 0) of the `IAST` list (i.e.
`int`	`hierarchy()` A unique integer ID for the implementation of this expression
`java.lang.String`	`internalFormString(boolean symbolsAsFactoryMethod, int depth)` Return the internal Java form of this expression.
`IExpr`	`inverse()` Returns the multiplicative inverse of this object.
`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.
`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)`.
`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)`.
`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)`.
`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)`.
`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)`.
`boolean`	`isASTSizeGE(IExpr header, int length)` Test if this expression is an AST (i.e.
`boolean`	`isAtom()` Test if this expression is an atomic expression (i.e.
`boolean`	`isComplex()` Test if this expression is a symbolic complex number
`boolean`	`isComplexInfinity()` Test if this expression is representing ComplexInfinity (i.e.
`boolean`	`isComplexNumeric()` Test if this expression is a numeric complex number
`boolean`	`isCondition()` Test if this expression is the Condition function `Condition[<arg1>, <arg2>]`
`boolean`	`isConstant()` Test if this expression is a symbol with attribute `Constant`.
`boolean`	`isCos()` Test if this expression is the function `Cos[<arg>]`
`boolean`	`isCosh()` Test if this expression is the function `Cosh[<arg>]`
`boolean`	`isDirectedInfinity()` Test if this expression is representing a DirectedInfinity (i.e.
`boolean`	`isFalse()` Test if this expression equals the symbol "False"
`boolean`	`isFlatAST()` Test if this expression is an AST list, which contains a header element (i.e.
`boolean`	`isFraction()` Test if this expression is a fractional number, but no integer number.
`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(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`	`isFunction()` Test if this expression is a `Funtion[ arg1 ]` expression with at least 1 argument.
`boolean`	`isGEOrdered(IExpr obj)` Compares this expression with the specified expression for order.
`boolean`	`isGTOrdered(IExpr expr)` 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`	`isLEOrdered(IExpr obj)` Compares this expression with the specified expression for order.
`boolean`	`isList()` Test if this expression is a list (i.e.
`boolean`	`isListOfLists()` Test if this expression is a list of lists
`boolean`	`isLog()` Test if this expression is the function `Log[<arg>]`
`boolean`	`isLTOrdered(IExpr expr)` Compares this expression with the specified expression for order.
`int[]`	`isMatrix()` Test if this expression is a matrix and return the dimensions as array [row-dimension, column-dimension].
`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.
`boolean`	`isMember(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`	`isMinusOne()` Test if this expression equals `-1` in symbolic or numeric mode.
`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`	`isNot()` Test if this expression is the function `Not[<arg>]`
`boolean`	`isNumber()` Test if this expression is a number
`boolean`	`isNumEqualInteger(IInteger ii)` Check if this expression equals an `IInteger` value.
`boolean`	`isNumeric()` Test if this expression is a numeric number (i.e.
`boolean`	`isNumericFunction()` Test if this expression is a numeric function (i.e.
`boolean`	`isNumIntValue()` Check if this expression represents an `int` value.
`boolean`	`isOne()` Test if this expression equals `1` in symbolic or numeric mode.
`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.
`boolean`	`isPattern()` Test if this expression is a pattern object
`boolean`	`isPatternExpr()` Test if this expression or a subexpression is a pattern object.
`boolean`	`isPatternSequence()` Test if this expression is a pattern sequence object
`boolean`	`isPlus()` Test if this expression is the addition function `Plus[<arg1>, <arg2>, ...]`
`boolean`	`isPositive()` Test if this object is a positive signed number.
`boolean`	`isPower()` Test if this expression is the function `Power[<arg1>, <arg2>]`
`boolean`	`isRational()` Test if this expression is a rational number, i.e.
`boolean`	`isRealFunction()` Test if this expression is a real (non-complex) value (i.e.
`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`	`isSequence()` Test if this expression is a sequence (i.e.
`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`	`isSymbol()` Test if this expression is a symbol
`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`	`isTrue()` Test if this expression equals the symbol "True"
`boolean`	`isValue()` Returns `true`, if this symbol or ast expression is bound to a value (i.e.
`int`	`isVector()` Test if this expression is a vector and return the dimension of the vector.
`boolean`	`isZero()` Test if this expression equals `0` in symbolic or numeric mode.
`java.util.List<IExpr>`	`leaves()`
`IExpr`	`minus(IExpr that)`
`IExpr`	`mod(IExpr that)`
`IExpr`	`multiply(IExpr that)` Multiply this with S.
`IExpr`	`negative()`
`IExpr`	`or(IExpr that)`
`IExpr`	`plus(IExpr that)`
`IExpr`	`power(IExpr that)`
`IExpr`	`power(java.lang.Integer n)`
`IExpr`	`replaceAll(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)`
`IExpr`	`replaceRepeated(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)`
`int`	`signum()` Deprecated.
`IExpr`	`times(IExpr that)` Returns the product of this object with the one specified.
`ISymbol`	`topHead()`
`IExpr`	`variables2Slots(java.util.Map<IExpr,IExpr> map, java.util.List<IExpr> variableList)` Convert the variables (i.e.

Methods inherited from interface edu.jas.structure.RingElem
egcd, gcd

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

Methods inherited from interface edu.jas.structure.MonoidElem
divide, isONE, isUnit, remainder

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

- Field Detail
  - ASTID
```
static final int ASTID
```
    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
  - 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:
  - 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 Element<IExpr>
    
    Returns:
    
    0 if this is equal to b, -1 if this is less then b, else +1.
  - evaluate
```
IExpr evaluate(EvalEngine engine)
```
    Evaluate an expression
    
    Parameters:
    
    engine - the evaluation engine
    
    Returns:
    
    the evaluated Object or null if the evaluation is not possible (i.e. the evaluation doesn't change the object).
  - 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:
  - 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
  - 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".
  - 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.
    
    Specified by:
    
    inverse in interface MonoidElem<IExpr>
    
    Returns:
    
    ONE / this.
  - isAnd
```
boolean isAnd()
```
    Test if this expression is the function And[<arg>,...]
  - isArcCos
```
boolean isArcCos()
```
    Test if this expression is the function ArcCos[<arg>]
  - isArcCosh
```
boolean isArcCosh()
```
    Test if this expression is the function ArcCosh[<arg>]
  - isArcSin
```
boolean isArcSin()
```
    Test if this expression is the function ArcSin[<arg>]
  - isArcSinh
```
boolean isArcSinh()
```
    Test if this expression is the function ArcSinh[<arg>]
  - isArcTan
```
boolean isArcTan()
```
    Test if this expression is the function ArcTan[<arg>]
  - isArcTanh
```
boolean isArcTanh()
```
    Test if this expression is the function ArcTanh[<arg>]
  - isAST
```
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()
  - isOrderlessAST
```
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()
  - isFlatAST
```
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()
  - isAST
```
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
```
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.
    
    See Also:
    
    isAtom()
  - isAST
```
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
```
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
```
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
```
boolean isASTSizeGE(IExpr header,
                    int length)
```
    Test if this expression is an AST (i.e. no atomic expression) with the given head expression and size of elements greater equal than the AST#size() 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
```
boolean isAtom()
```
    Test if this expression is an atomic expression (i.e. no AST expression)
  - isComplex
```
boolean isComplex()
```
    Test if this expression is a symbolic complex number
  - isComplexNumeric
```
boolean isComplexNumeric()
```
    Test if this expression is a numeric complex number
  - isConstant
```
boolean isConstant()
```
    Test if this expression is a symbol with attribute Constant. Therefore numbers return false for this method!
    
    See Also:
    
    isRealFunction(), isNumericFunction()
  - isComplexInfinity
```
boolean isComplexInfinity()
```
    Test if this expression is representing ComplexInfinity (i.e. DirectedInfinity[])
  - isDirectedInfinity
```
boolean isDirectedInfinity()
```
    Test if this expression is representing a DirectedInfinity (i.e. Infinity->DirectedInfinity[1], -Infinity->DirectedInfinity[-1], ComplexInfinity->DirectedInfinity[])
  - isInfinity
```
boolean isInfinity()
```
    Test if this expression is representing Infinity (i.e. Infinity->DirectedInfinity[1])
  - isNegative
```
boolean isNegative()
```
    Test if this object is a negative signed number.
    
    Returns:
    
    true, if this < 0; false in all other case.
  - isNegativeInfinity
```
boolean isNegativeInfinity()
```
    Test if this expression is representing -Infinity (i.e. -Infinity->DirectedInfinity[-1])
  - isCos
```
boolean isCos()
```
    Test if this expression is the function Cos[<arg>]
  - isCosh
```
boolean isCosh()
```
    Test if this expression is the function Cosh[<arg>]
  - isFalse
```
boolean isFalse()
```
    Test if this expression equals the symbol "False"
  - isFraction
```
boolean isFraction()
```
    Test if this expression is a fractional number, but no integer number.
  - isFree
```
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
```
boolean isFree(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.
  - isMember
```
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
```
boolean isMember(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.
  - isFunction
```
boolean isFunction()
```
    Test if this expression is a Funtion[ arg1 ] expression with at least 1 argument.
  - isGEOrdered
```
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).
    
    Parameters:
    
    expr - an expression to compare with
    
    Returns:
    
    true if this expression is canonical greater than or equal to the specified expression.
  - isGTOrdered
```
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.
  - isInteger
```
boolean isInteger()
```
    Test if this expression is a integer number
  - isNumIntValue
```
boolean isNumIntValue()
```
    Check if this expression represents an int value. The value of an INum object can be an int value.
    
    Returns:
  - isNumEqualInteger
```
boolean isNumEqualInteger(IInteger ii)
                   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 an IInteger value.
    
    Returns:
    
    Throws:
    
    java.lang.ArithmeticException
  - isLEOrdered
```
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
```
boolean isList()
```
    Test if this expression is a list (i.e. an AST with head List)
  - isSequence
```
boolean isSequence()
```
    Test if this expression is a sequence (i.e. an AST with head Sequence)
  - isListOfLists
```
boolean isListOfLists()
```
    Test if this expression is a list of lists
    
    See Also:
    
    isList(), isMatrix(), isVector()
  - isLog
```
boolean isLog()
```
    Test if this expression is the function Log[<arg>]
  - isLTOrdered
```
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
```
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
  - isNot
```
boolean isNot()
```
    Test if this expression is the function Not[<arg>]
  - isNumber
```
boolean isNumber()
```
    Test if this expression is a number
  - isOne
```
boolean isOne()
```
    Test if this expression equals 1 in symbolic or numeric mode.
  - isOr
```
boolean isOr()
```
    Test if this expression is the function Or[<arg>,...]
  - isMinusOne
```
boolean isMinusOne()
```
    Test if this expression equals -1 in symbolic or numeric mode.
  - isPlus
```
boolean isPlus()
```
    Test if this expression is the addition function Plus[<arg1>, <arg2>, ...]
  - isPattern
```
boolean isPattern()
```
    Test if this expression is a pattern object
  - isPatternExpr
```
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
```
boolean isPatternSequence()
```
    Test if this expression is a pattern sequence object
  - isPositive
```
boolean isPositive()
```
    Test if this object is a positive signed number.
    
    Returns:
    
    true, if this > 0; false in all other case.
  - isCondition
```
boolean isCondition()
```
    Test if this expression is the Condition function Condition[<arg1>, <arg2>]
  - isModule
```
boolean isModule()
```
    Test if this expression is the Module function Module[<arg1>, <arg2>]
  - isPower
```
boolean isPower()
```
    Test if this expression is the function Power[<arg1>, <arg2>]
  - isRational
```
boolean isRational()
```
    Test if this expression is a rational number, i.e. integer or fraction number.
  - isRuleAST
```
boolean isRuleAST()
```
    Test if this expression is of the form Rule[<arg1>, <arg2>] or RuleDelayed[<arg1>, <arg2>].
  - isSame
```
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
```
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
  - isSignedNumber
```
boolean isSignedNumber()
```
    Test if this expression is a signed number
  - isNumeric
```
boolean isNumeric()
```
    Test if this expression is a numeric number (i.e. of type INum or IComplexNum.
  - isNumericFunction
```
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()
  - isRealFunction
```
boolean isRealFunction()
```
    Test if this expression is a real (non-complex) value (i.e. a real number or a real symbolic constant or a Plus, Times expression with only real values)
    
    Returns:
    
    true, if the given expression is a real (non-complex) value.
    
    See Also:
    
    isConstant(), isNumericFunction()
  - isSin
```
boolean isSin()
```
    Test if this expression is the function Sin[<arg>]
  - isSinh
```
boolean isSinh()
```
    Test if this expression is the function Sinh[<arg>]
  - isSlot
```
boolean isSlot()
```
    Test if this expression is the function Slot[<integer-value>]
  - isSlotSequence
```
boolean isSlotSequence()
```
    Test if this expression is the function SlotSequence[<integer-value>]
  - isSymbol
```
boolean isSymbol()
```
    Test if this expression is a symbol
  - isTan
```
boolean isTan()
```
    Test if this expression is the function TAn[<arg>]
  - isTanh
```
boolean isTanh()
```
    Test if this expression is the function Tanh[<arg>]
  - isTimes
```
boolean isTimes()
```
    Test if this expression is the multiplication function Times[<arg1>, <arg2>, ...]
  - isTrue
```
boolean isTrue()
```
    Test if this expression equals the symbol "True"
  - isValue
```
boolean isValue()
```
    Returns true, if this symbol or ast expression is bound to a value (i.e. the evaluation returns an assigned value).
  - isVector
```
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 the corresponding IAST.
  - isZero
```
boolean isZero()
```
    Test if this expression equals 0 in symbolic or numeric mode.
  - leaves
```
java.util.List<IExpr> leaves()
```
    Returns:
    
    a list of the the leaf expressions. 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)
```
  - mod
```
IExpr mod(IExpr that)
```
  - multiply
```
IExpr multiply(IExpr that)
```
    Description copied from interface: MonoidElem
    
    Multiply this with S.
    
    Specified by:
    
    multiply in interface MonoidElem<IExpr>
    
    Returns:
    
    this * S.
  - negative
```
IExpr negative()
```
  - or
```
IExpr or(IExpr that)
```
  - plus
```
IExpr plus(IExpr that)
```
  - power
```
IExpr power(IExpr that)
```
  - power
```
IExpr power(java.lang.Integer n)
```
  - replaceAll
```
@Nullable
IExpr replaceAll(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 null the expression isn't substituted.
    
    Returns:
    
    null if no substitution of a (sub-)expression was possible.
  - replaceAll
```
@Nullable
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:
    
    null if no substitution of a (sub-)expression was possible.
  - replacePart
```
IExpr replacePart(IAST astRules)
```
  - replaceRepeated
```
IExpr replaceRepeated(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 astSlots)
```
  - 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 AbelianGroupElem<IExpr>
    
    Returns:
    
    the sign of this.
  - times
```
IExpr times(IExpr that)
```
    Returns the product of this object with the one specified.
    
    Parameters:
    
    that - the object multiplier.
    
    Returns:
    
    this · that.
  - topHead
```
ISymbol topHead()
```
    Returns:
    
    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.
  - variables2Slots
```
IExpr variables2Slots(java.util.Map<IExpr,IExpr> map,
                      java.util.List<IExpr> variableList)
```
    Convert the variables (i.e. ISymbol's with lower case character in the 0-th position of their name) in this expression into Slot[] s.
    
    Returns:
    
    null if the expression contains a variable with a '$' character in the 0-th position of its name and the math engine runs in server mode.

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

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

Field Detail

ASTID

COMPLEXID

DOUBLECOMPLEXID

DOUBLEID

FRACTIONID

INTEGERID

METHODSYMBOLID

PATTERNID

STRINGID

SYMBOLID

Method Detail

accept

accept

accept

and

apply

apply

asType

compareTo

evaluate

fullFormString

getAt

head

hierarchy

internalFormString

inverse

isAnd

isArcCos

isArcCosh

isArcSin

isArcSinh

isArcTan

isArcTanh

isAST

isOrderlessAST

isFlatAST

isAST

isAST

isAST

isAST

isAST

isASTSizeGE

isAtom

isComplex

isComplexNumeric

isConstant

isComplexInfinity

isDirectedInfinity

isInfinity

isNegative

isNegativeInfinity

isCos

isCosh

isFalse

isFraction

isFree

isFree

isMember

isMember

isFunction

isGEOrdered

isGTOrdered

isInteger

isNumIntValue

isNumEqualInteger

isLEOrdered

isList

isSequence

isListOfLists

isLog

isLTOrdered

isMatrix