ASTNode.Type

java.lang.Object
- java.lang.Enum<ASTNode.Type>
- - org.sbml.jsbml.ASTNode.Type

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<ASTNode.Type>

Enclosing class:

ASTNode
```
public static enum ASTNode.Type
extends java.lang.Enum<ASTNode.Type>
```
An enumeration of all possible types that can be represented by an abstract syntax tree node.

Author:

Andreas Dräger

Enum Constant Summary

Enum Constants
Enum Constant and Description
`CONSTANT_E` If the `ASTNode` represents Euler's constant, it should have this `ASTNode.Type`.
`CONSTANT_FALSE` If an `ASTNode` represents the `Boolean` attribute `Boolean.FALSE` it should have this `ASTNode.Type`.
`CONSTANT_PI` If the `ASTNode` represents the constant π, it should have this `ASTNode.Type`.
`CONSTANT_TRUE`
`CONSTRUCTOR_OTHERWISE`
`CONSTRUCTOR_PIECE`
`DIVIDE`
`FUNCTION` The type of an `ASTNode` containing a reference to a user-defined `FunctionDefinition`.
`FUNCTION_ABS`
`FUNCTION_ARCCOS`
`FUNCTION_ARCCOSH`
`FUNCTION_ARCCOT`
`FUNCTION_ARCCOTH`
`FUNCTION_ARCCSC`
`FUNCTION_ARCCSCH`
`FUNCTION_ARCSEC`
`FUNCTION_ARCSECH`
`FUNCTION_ARCSIN`
`FUNCTION_ARCSINH`
`FUNCTION_ARCTAN`
`FUNCTION_ARCTANH`
`FUNCTION_CEILING`
`FUNCTION_COS`
`FUNCTION_COSH`
`FUNCTION_COT`
`FUNCTION_COTH`
`FUNCTION_CSC`
`FUNCTION_CSCH`
`FUNCTION_DELAY`
`FUNCTION_EXP`
`FUNCTION_FACTORIAL`
`FUNCTION_FLOOR`
`FUNCTION_LN`
`FUNCTION_LOG`
`FUNCTION_MAX`
`FUNCTION_MIN`
`FUNCTION_PIECEWISE`
`FUNCTION_POWER` An `ASTNode` of this `ASTNode.Type` represents a function call of the 'pow' function.
`FUNCTION_QUOTIENT` The quotient element is the operator used for division modulo a particular base.
`FUNCTION_RATE_OF`
`FUNCTION_REM` The rem element is the operator that returns the "remainder" of a division modulo a particular base.
`FUNCTION_ROOT`
`FUNCTION_SEC`
`FUNCTION_SECH`
`FUNCTION_SELECTOR`
`FUNCTION_SIN`
`FUNCTION_SINH`
`FUNCTION_TAN`
`FUNCTION_TANH`
`INTEGER`
`LAMBDA` This type describes function definitions: The first n children of a node of this type are the arguments, and the last child is the function body.
`LOGICAL_AND`
`LOGICAL_IMPLIES` In classical logic, the compound 'p implies q' (p→q) is logically equivalent to the negative compound: not both p and not q.
`LOGICAL_NOT`
`LOGICAL_OR`
`LOGICAL_XOR`
`MINUS`
`NAME` `ASTNode`s of this `ASTNode.Type` refer to a `CallableSBase`.
`NAME_AVOGADRO` A type to express Avogadro's number.
`NAME_TIME`
`PLUS`
`POWER` This `ASTNode.Type` represents an operation with two children: a base and an exponent.
`PRODUCT`
`QUALIFIER_BVAR`
`QUALIFIER_DEGREE`
`QUALIFIER_LOGBASE`
`RATIONAL` An `ASTNode` of this `ASTNode.Type` contains two integer values: a numerator and a denominator.
`REAL` `ASTNode.Type` of an `ASTNode` that represents a single real value, i.e., a double number.
`REAL_E` `ASTNode.Type` of an `ASTNode` with a real value that is split in a double mantissa and an integer exponent.
`RELATIONAL_EQ` An `ASTNode` of this `ASTNode.Type` represents the relation symbol '=' to compare the values of all of its successors in the tree for equality.
`RELATIONAL_GEQ` Greater or equal
`RELATIONAL_GT` Greater than
`RELATIONAL_LEQ` Less or equal
`RELATIONAL_LT` Less than
`RELATIONAL_NEQ` Not equal
`SEMANTICS` MathML markup can be combined with other markup languages, and these mixing constructions are realized by the semantic annotation elements.
`SUM`
`TIMES`
`UNKNOWN`
`VECTOR`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static ASTNode.Type`	`getTypeFor(java.lang.String type)` Returns the `ASTNode.Type` corresponding to the given `String`.
`boolean`	`isDefinedIn(int level, int version)` Checks whether this type is valid for the given SBML Level/Version combination.
`static ASTNode.Type`	`valueOf(java.lang.String name)` Returns the enum constant of this type with the specified name.
`static ASTNode.Type[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

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

- Enum Constant Detail
  - CONSTANT_E
```
public static final ASTNode.Type CONSTANT_E
```
    If the ASTNode represents Euler's constant, it should have this ASTNode.Type.
  - CONSTANT_FALSE
```
public static final ASTNode.Type CONSTANT_FALSE
```
    If an ASTNode represents the Boolean attribute Boolean.FALSE it should have this ASTNode.Type.
  - CONSTANT_PI
```
public static final ASTNode.Type CONSTANT_PI
```
    If the ASTNode represents the constant π, it should have this ASTNode.Type.
  - CONSTRUCTOR_PIECE
```
public static final ASTNode.Type CONSTRUCTOR_PIECE
```
  - CONSTRUCTOR_OTHERWISE
```
public static final ASTNode.Type CONSTRUCTOR_OTHERWISE
```
  - CONSTANT_TRUE
```
public static final ASTNode.Type CONSTANT_TRUE
```
  - DIVIDE
```
public static final ASTNode.Type DIVIDE
```
  - FUNCTION
```
public static final ASTNode.Type FUNCTION
```
    The type of an ASTNode containing a reference to a user-defined FunctionDefinition.
  - FUNCTION_ABS
```
public static final ASTNode.Type FUNCTION_ABS
```
  - FUNCTION_ARCCOS
```
public static final ASTNode.Type FUNCTION_ARCCOS
```
  - FUNCTION_ARCCOSH
```
public static final ASTNode.Type FUNCTION_ARCCOSH
```
  - FUNCTION_ARCCOT
```
public static final ASTNode.Type FUNCTION_ARCCOT
```
  - FUNCTION_ARCCOTH
```
public static final ASTNode.Type FUNCTION_ARCCOTH
```
  - FUNCTION_ARCCSC
```
public static final ASTNode.Type FUNCTION_ARCCSC
```
  - FUNCTION_ARCCSCH
```
public static final ASTNode.Type FUNCTION_ARCCSCH
```
  - FUNCTION_ARCSEC
```
public static final ASTNode.Type FUNCTION_ARCSEC
```
  - FUNCTION_ARCSECH
```
public static final ASTNode.Type FUNCTION_ARCSECH
```
  - FUNCTION_ARCSIN
```
public static final ASTNode.Type FUNCTION_ARCSIN
```
  - FUNCTION_ARCSINH
```
public static final ASTNode.Type FUNCTION_ARCSINH
```
  - FUNCTION_ARCTAN
```
public static final ASTNode.Type FUNCTION_ARCTAN
```
  - FUNCTION_ARCTANH
```
public static final ASTNode.Type FUNCTION_ARCTANH
```
  - FUNCTION_CEILING
```
public static final ASTNode.Type FUNCTION_CEILING
```
  - FUNCTION_COS
```
public static final ASTNode.Type FUNCTION_COS
```
  - FUNCTION_COSH
```
public static final ASTNode.Type FUNCTION_COSH
```
  - FUNCTION_COT
```
public static final ASTNode.Type FUNCTION_COT
```
  - FUNCTION_COTH
```
public static final ASTNode.Type FUNCTION_COTH
```
  - FUNCTION_CSC
```
public static final ASTNode.Type FUNCTION_CSC
```
  - FUNCTION_CSCH
```
public static final ASTNode.Type FUNCTION_CSCH
```
  - FUNCTION_DELAY
```
public static final ASTNode.Type FUNCTION_DELAY
```
  - FUNCTION_EXP
```
public static final ASTNode.Type FUNCTION_EXP
```
  - FUNCTION_FACTORIAL
```
public static final ASTNode.Type FUNCTION_FACTORIAL
```
  - FUNCTION_FLOOR
```
public static final ASTNode.Type FUNCTION_FLOOR
```
  - FUNCTION_LN
```
public static final ASTNode.Type FUNCTION_LN
```
  - FUNCTION_LOG
```
public static final ASTNode.Type FUNCTION_LOG
```
  - FUNCTION_MAX
```
public static final ASTNode.Type FUNCTION_MAX
```
  - FUNCTION_MIN
```
public static final ASTNode.Type FUNCTION_MIN
```
  - FUNCTION_PIECEWISE
```
public static final ASTNode.Type FUNCTION_PIECEWISE
```
  - FUNCTION_POWER
```
public static final ASTNode.Type FUNCTION_POWER
```
    An ASTNode of this ASTNode.Type represents a function call of the 'pow' function. This function takes two arguments, the base and the exponent. Alternatively, also POWER can be used, which represents the simple text symbol '^' to achieve the same effect.
  - FUNCTION_QUOTIENT
```
public static final ASTNode.Type FUNCTION_QUOTIENT
```
    The quotient element is the operator used for division modulo a particular base. When the quotient operator is applied to integer arguments a and b, the result is the "quotient of a divided by b". That is, quotient returns the unique integer q such that a = q b + r. (In common usage, q is called the quotient and r is the remainder.)
  - FUNCTION_RATE_OF
```
public static final ASTNode.Type FUNCTION_RATE_OF
```
  - FUNCTION_REM
```
public static final ASTNode.Type FUNCTION_REM
```
    The rem element is the operator that returns the "remainder" of a division modulo a particular base. When the rem operator is applied to integer arguments a and b, the result is the "remainder of a divided by b". That is, rem returns the unique integer, r such that a = q b+ r, where r < q. (In common usage, q is called the quotient and r is the remainder.)
  - FUNCTION_ROOT
```
public static final ASTNode.Type FUNCTION_ROOT
```
  - FUNCTION_SEC
```
public static final ASTNode.Type FUNCTION_SEC
```
  - FUNCTION_SECH
```
public static final ASTNode.Type FUNCTION_SECH
```
  - FUNCTION_SELECTOR
```
public static final ASTNode.Type FUNCTION_SELECTOR
```
  - FUNCTION_SIN
```
public static final ASTNode.Type FUNCTION_SIN
```
  - FUNCTION_SINH
```
public static final ASTNode.Type FUNCTION_SINH
```
  - FUNCTION_TAN
```
public static final ASTNode.Type FUNCTION_TAN
```
  - FUNCTION_TANH
```
public static final ASTNode.Type FUNCTION_TANH
```
  - INTEGER
```
public static final ASTNode.Type INTEGER
```
  - LAMBDA
```
public static final ASTNode.Type LAMBDA
```
    This type describes function definitions: The first n children of a node of this type are the arguments, and the last child is the function body.
  - LOGICAL_AND
```
public static final ASTNode.Type LOGICAL_AND
```
  - LOGICAL_IMPLIES
```
public static final ASTNode.Type LOGICAL_IMPLIES
```
    In classical logic, the compound 'p implies q' (p→q) is logically equivalent to the negative compound: not both p and not q. Thus the compound p→q is false if and only if both p is true and q is false. By the same stroke, p→q is true if and only if either p is false or q is true (or both). Thus → is a function from pairs of truth values of the components p, q to truth values of the compound p→q, whose truth value is entirely a function of the truth values of the components. Hence, this interpretation is called truth-functional. The compound p→q is logically equivalent also to ¬p∨q (either not p, or q (or both)), and to ¬q→¬p (if not q then not p). But it is not equivalent to ¬p→¬q, which is equivalent to q→p.
    Truth table:
```
 p   q  p→q
 
 T   T   T
 T   F   F
 F   T   T
 F   F   T
```
  - LOGICAL_NOT
```
public static final ASTNode.Type LOGICAL_NOT
```
  - LOGICAL_OR
```
public static final ASTNode.Type LOGICAL_OR
```
  - LOGICAL_XOR
```
public static final ASTNode.Type LOGICAL_XOR
```
  - MINUS
```
public static final ASTNode.Type MINUS
```
  - NAME
```
public static final ASTNode.Type NAME
```
    ASTNodes of this ASTNode.Type refer to a CallableSBase.
  - NAME_AVOGADRO
```
public static final ASTNode.Type NAME_AVOGADRO
```
    A type to express Avogadro's number.
  - NAME_TIME
```
public static final ASTNode.Type NAME_TIME
```
  - PLUS
```
public static final ASTNode.Type PLUS
```
  - POWER
```
public static final ASTNode.Type POWER
```
    This ASTNode.Type represents an operation with two children: a base and an exponent. In textual form, this type is represented by the symbol '^'.
  - PRODUCT
```
public static final ASTNode.Type PRODUCT
```
  - QUALIFIER_BVAR
```
public static final ASTNode.Type QUALIFIER_BVAR
```
  - QUALIFIER_DEGREE
```
public static final ASTNode.Type QUALIFIER_DEGREE
```
  - QUALIFIER_LOGBASE
```
public static final ASTNode.Type QUALIFIER_LOGBASE
```
  - RATIONAL
```
public static final ASTNode.Type RATIONAL
```
    An ASTNode of this ASTNode.Type contains two integer values: a numerator and a denominator.
  - REAL
```
public static final ASTNode.Type REAL
```
    ASTNode.Type of an ASTNode that represents a single real value, i.e., a double number.
  - REAL_E
```
public static final ASTNode.Type REAL_E
```
    ASTNode.Type of an ASTNode with a real value that is split in a double mantissa and an integer exponent.
  - RELATIONAL_EQ
```
public static final ASTNode.Type RELATIONAL_EQ
```
    An ASTNode of this ASTNode.Type represents the relation symbol '=' to compare the values of all of its successors in the tree for equality.
  - RELATIONAL_GEQ
```
public static final ASTNode.Type RELATIONAL_GEQ
```
    Greater or equal
  - RELATIONAL_GT
```
public static final ASTNode.Type RELATIONAL_GT
```
    Greater than
  - RELATIONAL_LEQ
```
public static final ASTNode.Type RELATIONAL_LEQ
```
    Less or equal
  - RELATIONAL_LT
```
public static final ASTNode.Type RELATIONAL_LT
```
    Less than
  - RELATIONAL_NEQ
```
public static final ASTNode.Type RELATIONAL_NEQ
```
    Not equal
  - SUM
```
public static final ASTNode.Type SUM
```
  - TIMES
```
public static final ASTNode.Type TIMES
```
  - SEMANTICS
```
public static final ASTNode.Type SEMANTICS
```
    MathML markup can be combined with other markup languages, and these mixing constructions are realized by the semantic annotation elements. The semantic annotation elements provide an important tool for making associations between alternate representations of an expression, and for associating semantic properties and other attributions with a MathML expression.
  - UNKNOWN
```
public static final ASTNode.Type UNKNOWN
```
  - VECTOR
```
public static final ASTNode.Type VECTOR
```
- Method Detail
  - values
```
public static ASTNode.Type[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (ASTNode.Type c : ASTNode.Type.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static ASTNode.Type valueOf(java.lang.String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
    
    java.lang.NullPointerException - if the argument is null
  - getTypeFor
```
public static ASTNode.Type getTypeFor(java.lang.String type)
```
    Returns the ASTNode.Type corresponding to the given String.
    
    Parameters:
    
    type - e.g., sin, asin, exp, and so on. See the specification of the MathML subset used in SBML.
    
    Returns:
    
    The type corresponding to the given String or UNKNOWN if no matching can be found.
  - isDefinedIn
```
public boolean isDefinedIn(int level,
                           int version)
```
    Checks whether this type is valid for the given SBML Level/Version combination.
    
    Parameters:
    
    level -
    
    version -
    
    Returns:
    
    whether this type is valid for the given SBML Level/Version combination.

Enum ASTNode.Type

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

CONSTANT_E

CONSTANT_FALSE

CONSTANT_PI

CONSTRUCTOR_PIECE

CONSTRUCTOR_OTHERWISE

CONSTANT_TRUE

DIVIDE

FUNCTION

FUNCTION_ABS

FUNCTION_ARCCOS

FUNCTION_ARCCOSH

FUNCTION_ARCCOT

FUNCTION_ARCCOTH

FUNCTION_ARCCSC

FUNCTION_ARCCSCH

FUNCTION_ARCSEC

FUNCTION_ARCSECH

FUNCTION_ARCSIN

FUNCTION_ARCSINH

FUNCTION_ARCTAN

FUNCTION_ARCTANH

FUNCTION_CEILING

FUNCTION_COS

FUNCTION_COSH

FUNCTION_COT

FUNCTION_COTH

FUNCTION_CSC

FUNCTION_CSCH

FUNCTION_DELAY

FUNCTION_EXP

FUNCTION_FACTORIAL

FUNCTION_FLOOR

FUNCTION_LN

FUNCTION_LOG

FUNCTION_MAX

FUNCTION_MIN

FUNCTION_PIECEWISE

FUNCTION_POWER

FUNCTION_QUOTIENT

FUNCTION_RATE_OF

FUNCTION_REM

FUNCTION_ROOT

FUNCTION_SEC

FUNCTION_SECH

FUNCTION_SELECTOR

FUNCTION_SIN

FUNCTION_SINH

FUNCTION_TAN

FUNCTION_TANH

INTEGER

LAMBDA

LOGICAL_AND

LOGICAL_IMPLIES

LOGICAL_NOT

LOGICAL_OR

LOGICAL_XOR

MINUS

NAME

NAME_AVOGADRO

NAME_TIME

PLUS

POWER

PRODUCT

QUALIFIER_BVAR

QUALIFIER_DEGREE

QUALIFIER_LOGBASE

RATIONAL

REAL

REAL_E

RELATIONAL_EQ

RELATIONAL_GEQ

RELATIONAL_GT

RELATIONAL_LEQ

RELATIONAL_LT