libSBML Python API  5.8.0
 All Classes Namespaces Files Functions Variables Pages
libsbml.ASTNode Class Reference
Inheritance diagram for libsbml.ASTNode:
[legend]

Detailed Description

Abstract Syntax Tree (AST) representation of a mathematical expression.

This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML.

Abstract Syntax Trees (ASTs) are a simple kind of data structure used in libSBML for storing mathematical expressions. The ASTNode is the cornerstone of libSBML's AST representation. An AST 'node' represents the most basic, indivisible part of a mathematical formula and come in many types. For instance, there are node types to represent numbers (with subtypes to distinguish integer, real, and rational numbers), names (e.g., constants or variables), simple mathematical operators, logical or relational operators and functions. LibSBML ASTs provide a canonical, in-memory representation for all mathematical formulas regardless of their original format (which might be MathML or might be text strings).

An AST node in libSBML is a recursive structure containing a pointer to the node's value (which might be, for example, a number or a symbol) and a list of children nodes. Each ASTNode node may have none, one, two, or more children depending on its type. The following diagram illustrates an example of how the mathematical expression '1 + 2' is represented as an AST with one plus node having two integer children nodes for the numbers 1 and 2. The figure also shows the corresponding MathML representation:

Example AST representation of a mathematical expression.
Infix AST MathML
1 + 2 <math xmlns="http://www.w3.org/1998/Math/MathML">
  <apply>
    <plus/>
    <cn type="integer"> 1 </cn>
    <cn type="integer"> 2 </cn>
  </apply>
</math>

The following are other noteworthy points about the AST representation in libSBML:

  • A numerical value represented in MathML as a real number with an exponent is preserved as such in the AST node representation, even if the number could be stored in a float data type. This is done so that when an SBML model is read in and then written out again, the amount of change introduced by libSBML to the SBML during the round-trip activity is minimized.

  • Rational numbers are represented in an AST node using separate numerator and denominator values. These can be retrieved using the methods ASTNode.getNumerator() and ASTNode.getDenominator().

  • The children of an ASTNode are other ASTNode objects. The list of children is empty for nodes that are leaf elements, such as numbers. For nodes that are actually roots of expression subtrees, the list of children points to the parsed objects that make up the rest of the expression.

The set of possible ASTNode types

Every ASTNode has an associated type code to indicate, for example, whether it holds a number or stands for an arithmetic operator. The type is recorded as a value drawn from a set of static integer constants defined in the class libsbml. Their names begin with the characters AST_.The list of possible types is quite long, because it covers all the mathematical functions that are permitted in SBML. The values are shown in the following table:

  • AST_CONSTANT_E
  • AST_CONSTANT_FALSE
  • AST_CONSTANT_PI
  • AST_CONSTANT_TRUE
  • AST_DIVIDE
  • AST_FUNCTION
  • AST_FUNCTION_ABS
  • AST_FUNCTION_ARCCOS
  • AST_FUNCTION_ARCCOSH
  • AST_FUNCTION_ARCCOT
  • AST_FUNCTION_ARCCOTH
  • AST_FUNCTION_ARCCSC
  • AST_FUNCTION_ARCCSCH
  • AST_FUNCTION_ARCSEC
  • AST_FUNCTION_ARCSECH
  • AST_FUNCTION_ARCSIN
  • AST_FUNCTION_ARCSINH
  • AST_FUNCTION_ARCTAN
  • AST_FUNCTION_ARCTANH
  • AST_FUNCTION_CEILING
  • AST_FUNCTION_COS
  • AST_FUNCTION_COSH
  • AST_FUNCTION_COT
  • AST_FUNCTION_COTH
  • AST_FUNCTION_CSC
  • AST_FUNCTION_CSCH
  • AST_FUNCTION_DELAY
  • AST_FUNCTION_EXP
  • AST_FUNCTION_FACTORIAL
  • AST_FUNCTION_FLOOR
  • AST_FUNCTION_LN
  • AST_FUNCTION_LOG
  • AST_FUNCTION_PIECEWISE
  • AST_FUNCTION_POWER
  • AST_FUNCTION_ROOT
  • AST_FUNCTION_SEC
  • AST_FUNCTION_SECH
  • AST_FUNCTION_SIN
  • AST_FUNCTION_SINH
  • AST_FUNCTION_TAN
  • AST_FUNCTION_TANH
  • AST_INTEGER
  • AST_LAMBDA
  • AST_LOGICAL_AND
  • AST_LOGICAL_NOT
  • AST_LOGICAL_OR
  • AST_LOGICAL_XOR
  • AST_MINUS
  • AST_NAME
  • AST_NAME_AVOGADRO (Level 3 only)
  • AST_NAME_TIME
  • AST_PLUS
  • AST_POWER
  • AST_RATIONAL
  • AST_REAL
  • AST_REAL_E
  • AST_RELATIONAL_EQ
  • AST_RELATIONAL_GEQ
  • AST_RELATIONAL_GT
  • AST_RELATIONAL_LEQ
  • AST_RELATIONAL_LT
  • AST_RELATIONAL_NEQ
  • AST_TIMES
  • AST_UNKNOWN

The types have the following meanings:

  • If the node is basic mathematical operator (e.g., '+'), then the node's type will be AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE, or AST_POWER, as appropriate.

  • If the node is a predefined function or operator from SBML Level 1 (in the string-based formula syntax used in Level 1) or SBML Levels 2 and 3 (in the subset of MathML used in SBML Levels 2 and 3), then the node's type will be either AST_FUNCTION_X, AST_LOGICAL_X, or AST_RELATIONAL_X, as appropriate. (Examples: AST_FUNCTION_LOG, AST_RELATIONAL_LEQ.)

  • If the node refers to a user-defined function, the node's type will be AST_FUNCTION (because it holds the name of the function).

  • If the node is a lambda expression, its type will be AST_LAMBDA.

  • If the node is a predefined constant ('ExponentialE', 'Pi', 'True' or 'False'), then the node's type will be AST_CONSTANT_E, AST_CONSTANT_PI, AST_CONSTANT_TRUE, or AST_CONSTANT_FALSE.

  • (Levels 2 and 3 only) If the node is the special MathML csymbol time, the value of the node will be AST_NAME_TIME. (Note, however, that the MathML csymbol delay is translated into a node of type AST_FUNCTION_DELAY. The difference is due to the fact that time is a single variable, whereas delay is actually a function taking arguments.)

  • (Level 3 only) If the node is the special MathML csymbol avogadro, the value of the node will be AST_NAME_AVOGADRO.

  • If the node contains a numerical value, its type will be AST_INTEGER, AST_REAL, AST_REAL_E, or AST_RATIONAL, as appropriate.

Converting between ASTs and text strings

The text-string form of mathematical formulas produced bylibsbml.formulaToString() and read bylibsbml.parseFormula() and libsbml.parseL3Formula() are in a simple C-inspired infix notation. A formula in this text-string form can be handed to a program that understands SBML mathematical expressions, or used as part of a translation system. The libSBML distribution comes with an example program in the 'examples' subdirectory called translateMath that implements an interactive command-line demonstration of translating infix formulas into MathML and vice-versa.

The formula strings may contain operators, function calls, symbols, and white space characters. The allowable white space characters are tab and space. The following are illustrative examples of formulas expressed in the syntax:

 0.10 * k4^2
 (vm * s1)/(km + s1)

The following table shows the precedence rules in this syntax. In the Class column, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a * b + c is evaluated as (a * b) + c because the * operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a - b + c is evaluated as (a - b) + c because the + and - operators are left-associative. The precedence and associativity rules are taken from the C programming language, except for the symbol ^, which is used in C for a different purpose. (Exponentiation can be invoked using either ^ or the function power.)

Token Operation Class Precedence Associates
namesymbol referenceoperand6n/a
(expression)expression groupingoperand6n/a
f(...)function callprefix6left
-negationunary5right
^powerbinary4left
*multiplicationbinary3left
/divisonbinary3left
+additionbinary2left
-subtractionbinary2left
,argument delimiterbinary1left
A table of the expression operators and their precedence in the text-string format for mathematical expressions used by SBML_parseFormula().

A program parsing a formula in an SBML model should assume that names appearing in the formula are the identifiers of Species, Parameter, Compartment, FunctionDefinition, Reaction (in SBML Levels 2 and 3), or SpeciesReference (in SBML Level 3 only) objects defined in a model. When a function call is involved, the syntax consists of a function identifier, followed by optional white space, followed by an opening parenthesis, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis. There is an almost one-to-one mapping between the list of predefined functions available, and those defined in MathML. All of the MathML functions are recognized; this set is larger than the functions defined in SBML Level 1. In the subset of functions that overlap between MathML and SBML Level 1, there exist a few differences. The following table summarizes the differences between the predefined functions in SBML Level 1 and the MathML equivalents in SBML Levels 2 and  3:

Text string formula functions MathML equivalents in SBML Levels 2 and 3
acosarccos
asinarcsin
atanarctan
ceilceiling
logln
log10(x)log(10, x)
pow(x, y)power(x, y)
sqr(x)power(x, 2)
sqrt(x)root(2, x)
Table comparing the names of certain functions in the SBML text-string formula syntax and MathML. The left column shows the names of functions recognized by SBML_parseFormula(); the right column shows their equivalent function names in MathML 2.0, used in SBML Levels 2 and 3.
Warning
We urge developers to keep in mind that the text-string formula syntax is specific to SBML Level 1's C-like mathematical formula syntax. In particular, it is not a general-purpose mathematical expression syntax. LibSBML provides methods for parsing and transforming text-string math formulas back and forth from AST structures, but it is important to keep the system's limitations in mind.
See Also
libsbml.parseL3Formula()
libsbml.parseFormula()

Public Member Functions

def addChild
 
def addSemanticsAnnotation
 
def canonicalize
 
def deepCopy
 
def freeName
 
def getCharacter
 
def getChild
 
def getClass
 
def getDefinitionURL
 
def getDenominator
 
def getExponent
 
def getId
 
def getInteger
 
def getLeftChild
 
def getListOfNodes
 
def getMantissa
 
def getName
 
def getNumChildren
 
def getNumerator
 
def getNumSemanticsAnnotations
 
def getOperatorName
 
def getParentSBMLObject
 
def getPrecedence
 
def getReal
 
def getRightChild
 
def getSemanticsAnnotation
 
def getStyle
 
def getType
 
def getUnits
 
def hasCorrectNumberArguments
 
def hasUnits
 
def insertChild
 
def isAvogadro
 
def isBoolean
 
def isConstant
 
def isFunction
 
def isInfinity
 
def isInteger
 
def isLambda
 
def isLog10
 
def isLogical
 
def isName
 
def isNaN
 
def isNegInfinity
 
def isNumber
 
def isOperator
 
def isPiecewise
 
def isRational
 
def isReal
 
def isRelational
 
def isSetClass
 
def isSetId
 
def isSetStyle
 
def isSetUnits
 
def isSqrt
 
def isUMinus
 
def isUnknown
 
def isUPlus
 
def isWellFormedASTNode
 
def prependChild
 
def reduceToBinary
 
def removeChild
 
def renameSIdRefs
 
def renameUnitSIdRefs
 
def replaceArgument
 
def replaceChild
 
def returnsBoolean
 
def setCharacter
 
def setClass
 
def setId
 
def setName
 
def setStyle
 
def setType
 
def setUnits
 
def setValue
 
def swapChildren
 
def unsetClass
 
def unsetId
 
def unsetStyle
 
def unsetUnits
 

Member Function Documentation

def libsbml.ASTNode.addChild (   self,
  args 
)

Python method signature(s):

addChild(ASTNode self, ASTNode child)   int

Adds the given node as a child of this ASTNode. Child nodes are added in-order, from left to right.

Parameters
childthe ASTNode instance to add
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Adding a child to an ASTNode may change the structure of the mathematical formula being represented by the tree structure, and may render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications.
See Also
prependChild()
replaceChild()
insertChild()
removeChild()
isWellFormedASTNode()
def libsbml.ASTNode.addSemanticsAnnotation (   self,
  args 
)

Python method signature(s):

addSemanticsAnnotation(ASTNode self, XMLNode sAnnotation)   int

Adds the given XMLNode as a semantic annotation of this ASTNode.

The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs.
Parameters
sAnnotationthe annotation to add.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Although SBML permits the semantic annotation construct in MathML expressions, the truth is that this construct has so far (at this time of this writing, which is early 2011) seen very little use in SBML software. The full implications of using semantic annotations are still poorly understood. If you wish to use this construct, we urge you to discuss possible uses and applications on the SBML discussion lists, particularly sbml-discuss&#64;caltech.edu and/or sbml-interoperability&#64;caltech.edu.
def libsbml.ASTNode.canonicalize (   self)

Python method signature(s):

canonicalize(ASTNode self)   bool

Converts this ASTNode to a canonical form and returns True if successful, False otherwise.

The rules determining the canonical form conversion are as follows:

  • If the node type is AST_NAME and the node name matches 'ExponentialE', 'Pi', 'True' or 'False' the node type is converted to the corresponding AST_CONSTANT_X type.

  • If the node type is an AST_FUNCTION and the node name matches an SBML (MathML) function name, logical operator name, or relational operator name, the node is converted to the corresponding AST_FUNCTION_X or AST_LOGICAL_X type.

SBML Level 1 function names are searched first; thus, for example, canonicalizing log will result in a node type of AST_FUNCTION_LN. (See the SBML Level 1 Version 2 Specification, Appendix C.)

Sometimes, canonicalization of a node results in a structural conversion of the node as a result of adding a child. For example, a node with the SBML Level 1 function name sqr and a single child node (the argument) will be transformed to a node of type AST_FUNCTION_POWER with two children. The first child will remain unchanged, but the second child will be an ASTNode of type AST_INTEGER and a value of 2. The function names that result in structural changes are: log10, sqr, and sqrt.

def libsbml.ASTNode.deepCopy (   self)

Python method signature(s):

deepCopy(ASTNode self)   ASTNode

Creates a recursive copy of this node and all its children.

Returns
a copy of this ASTNode and all its children. The caller owns the returned ASTNode and is reponsible for deleting it.
def libsbml.ASTNode.freeName (   self)

Abstract Syntax Tree (AST) representation of a mathematical expression.

This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML.

Abstract Syntax Trees (ASTs) are a simple kind of data structure used in libSBML for storing mathematical expressions. The ASTNode is the cornerstone of libSBML's AST representation. An AST 'node' represents the most basic, indivisible part of a mathematical formula and come in many types. For instance, there are node types to represent numbers (with subtypes to distinguish integer, real, and rational numbers), names (e.g., constants or variables), simple mathematical operators, logical or relational operators and functions. LibSBML ASTs provide a canonical, in-memory representation for all mathematical formulas regardless of their original format (which might be MathML or might be text strings).

An AST node in libSBML is a recursive structure containing a pointer to the node's value (which might be, for example, a number or a symbol) and a list of children nodes. Each ASTNode node may have none, one, two, or more children depending on its type. The following diagram illustrates an example of how the mathematical expression '1 + 2' is represented as an AST with one plus node having two integer children nodes for the numbers 1 and 2. The figure also shows the corresponding MathML representation:

Example AST representation of a mathematical expression.
Infix AST MathML
1 + 2 <math xmlns="http://www.w3.org/1998/Math/MathML">
  <apply>
    <plus/>
    <cn type="integer"> 1 </cn>
    <cn type="integer"> 2 </cn>
  </apply>
</math>

The following are other noteworthy points about the AST representation in libSBML:

  • A numerical value represented in MathML as a real number with an exponent is preserved as such in the AST node representation, even if the number could be stored in a float data type. This is done so that when an SBML model is read in and then written out again, the amount of change introduced by libSBML to the SBML during the round-trip activity is minimized.

  • Rational numbers are represented in an AST node using separate numerator and denominator values. These can be retrieved using the methods ASTNode.getNumerator() and ASTNode.getDenominator().

  • The children of an ASTNode are other ASTNode objects. The list of children is empty for nodes that are leaf elements, such as numbers. For nodes that are actually roots of expression subtrees, the list of children points to the parsed objects that make up the rest of the expression.

The set of possible ASTNode types

Every ASTNode has an associated type code to indicate, for example, whether it holds a number or stands for an arithmetic operator. The type is recorded as a value drawn from a set of static integer constants defined in the class libsbml. Their names begin with the characters AST_.The list of possible types is quite long, because it covers all the mathematical functions that are permitted in SBML. The values are shown in the following table:

  • AST_CONSTANT_E
  • AST_CONSTANT_FALSE
  • AST_CONSTANT_PI
  • AST_CONSTANT_TRUE
  • AST_DIVIDE
  • AST_FUNCTION
  • AST_FUNCTION_ABS
  • AST_FUNCTION_ARCCOS
  • AST_FUNCTION_ARCCOSH
  • AST_FUNCTION_ARCCOT
  • AST_FUNCTION_ARCCOTH
  • AST_FUNCTION_ARCCSC
  • AST_FUNCTION_ARCCSCH
  • AST_FUNCTION_ARCSEC
  • AST_FUNCTION_ARCSECH
  • AST_FUNCTION_ARCSIN
  • AST_FUNCTION_ARCSINH
  • AST_FUNCTION_ARCTAN
  • AST_FUNCTION_ARCTANH
  • AST_FUNCTION_CEILING
  • AST_FUNCTION_COS
  • AST_FUNCTION_COSH
  • AST_FUNCTION_COT
  • AST_FUNCTION_COTH
  • AST_FUNCTION_CSC
  • AST_FUNCTION_CSCH
  • AST_FUNCTION_DELAY
  • AST_FUNCTION_EXP
  • AST_FUNCTION_FACTORIAL
  • AST_FUNCTION_FLOOR
  • AST_FUNCTION_LN
  • AST_FUNCTION_LOG
  • AST_FUNCTION_PIECEWISE
  • AST_FUNCTION_POWER
  • AST_FUNCTION_ROOT
  • AST_FUNCTION_SEC
  • AST_FUNCTION_SECH
  • AST_FUNCTION_SIN
  • AST_FUNCTION_SINH
  • AST_FUNCTION_TAN
  • AST_FUNCTION_TANH
  • AST_INTEGER
  • AST_LAMBDA
  • AST_LOGICAL_AND
  • AST_LOGICAL_NOT
  • AST_LOGICAL_OR
  • AST_LOGICAL_XOR
  • AST_MINUS
  • AST_NAME
  • AST_NAME_AVOGADRO (Level 3 only)
  • AST_NAME_TIME
  • AST_PLUS
  • AST_POWER
  • AST_RATIONAL
  • AST_REAL
  • AST_REAL_E
  • AST_RELATIONAL_EQ
  • AST_RELATIONAL_GEQ
  • AST_RELATIONAL_GT
  • AST_RELATIONAL_LEQ
  • AST_RELATIONAL_LT
  • AST_RELATIONAL_NEQ
  • AST_TIMES
  • AST_UNKNOWN

The types have the following meanings:

  • If the node is basic mathematical operator (e.g., '+'), then the node's type will be AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE, or AST_POWER, as appropriate.

  • If the node is a predefined function or operator from SBML Level 1 (in the string-based formula syntax used in Level 1) or SBML Levels 2 and 3 (in the subset of MathML used in SBML Levels 2 and 3), then the node's type will be either AST_FUNCTION_X, AST_LOGICAL_X, or AST_RELATIONAL_X, as appropriate. (Examples: AST_FUNCTION_LOG, AST_RELATIONAL_LEQ.)

  • If the node refers to a user-defined function, the node's type will be AST_FUNCTION (because it holds the name of the function).

  • If the node is a lambda expression, its type will be AST_LAMBDA.

  • If the node is a predefined constant ('ExponentialE', 'Pi', 'True' or 'False'), then the node's type will be AST_CONSTANT_E, AST_CONSTANT_PI, AST_CONSTANT_TRUE, or AST_CONSTANT_FALSE.

  • (Levels 2 and 3 only) If the node is the special MathML csymbol time, the value of the node will be AST_NAME_TIME. (Note, however, that the MathML csymbol delay is translated into a node of type AST_FUNCTION_DELAY. The difference is due to the fact that time is a single variable, whereas delay is actually a function taking arguments.)

  • (Level 3 only) If the node is the special MathML csymbol avogadro, the value of the node will be AST_NAME_AVOGADRO.

  • If the node contains a numerical value, its type will be AST_INTEGER, AST_REAL, AST_REAL_E, or AST_RATIONAL, as appropriate.

Converting between ASTs and text strings

The text-string form of mathematical formulas produced bylibsbml.formulaToString() and read bylibsbml.parseFormula() and libsbml.parseL3Formula() are in a simple C-inspired infix notation. A formula in this text-string form can be handed to a program that understands SBML mathematical expressions, or used as part of a translation system. The libSBML distribution comes with an example program in the 'examples' subdirectory called translateMath that implements an interactive command-line demonstration of translating infix formulas into MathML and vice-versa.

The formula strings may contain operators, function calls, symbols, and white space characters. The allowable white space characters are tab and space. The following are illustrative examples of formulas expressed in the syntax:

 0.10 * k4^2
 (vm * s1)/(km + s1)

The following table shows the precedence rules in this syntax. In the Class column, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a * b + c is evaluated as (a * b) + c because the * operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a - b + c is evaluated as (a - b) + c because the + and - operators are left-associative. The precedence and associativity rules are taken from the C programming language, except for the symbol ^, which is used in C for a different purpose. (Exponentiation can be invoked using either ^ or the function power.)

Token Operation Class Precedence Associates
namesymbol referenceoperand6n/a
(expression)expression groupingoperand6n/a
f(...)function callprefix6left
-negationunary5right
^powerbinary4left
*multiplicationbinary3left
/divisonbinary3left
+additionbinary2left
-subtractionbinary2left
,argument delimiterbinary1left
A table of the expression operators and their precedence in the text-string format for mathematical expressions used by SBML_parseFormula().

A program parsing a formula in an SBML model should assume that names appearing in the formula are the identifiers of Species, Parameter, Compartment, FunctionDefinition, Reaction (in SBML Levels 2 and 3), or SpeciesReference (in SBML Level 3 only) objects defined in a model. When a function call is involved, the syntax consists of a function identifier, followed by optional white space, followed by an opening parenthesis, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis. There is an almost one-to-one mapping between the list of predefined functions available, and those defined in MathML. All of the MathML functions are recognized; this set is larger than the functions defined in SBML Level 1. In the subset of functions that overlap between MathML and SBML Level 1, there exist a few differences. The following table summarizes the differences between the predefined functions in SBML Level 1 and the MathML equivalents in SBML Levels 2 and  3:

Text string formula functions MathML equivalents in SBML Levels 2 and 3
acosarccos
asinarcsin
atanarctan
ceilceiling
logln
log10(x)log(10, x)
pow(x, y)power(x, y)
sqr(x)power(x, 2)
sqrt(x)root(2, x)
Table comparing the names of certain functions in the SBML text-string formula syntax and MathML. The left column shows the names of functions recognized by SBML_parseFormula(); the right column shows their equivalent function names in MathML 2.0, used in SBML Levels 2 and 3.
Warning
We urge developers to keep in mind that the text-string formula syntax is specific to SBML Level 1's C-like mathematical formula syntax. In particular, it is not a general-purpose mathematical expression syntax. LibSBML provides methods for parsing and transforming text-string math formulas back and forth from AST structures, but it is important to keep the system's limitations in mind.
See Also
libsbml.parseL3Formula()
libsbml.parseFormula() Python method signature(s):
freeName(ASTNode self)   int

Frees the name of this ASTNode and sets it to None.

This operation is only applicable to ASTNode objects corresponding to operators, numbers, or AST_UNKNOWN. This method has no effect on other types of nodes.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.getCharacter (   self)

Python method signature(s):

getCharacter(ASTNode self)   string

Get the value of this node as a single character. This function should be called only when ASTNode.getType() returns AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE or AST_POWER.

Returns
the value of this ASTNode as a single character
def libsbml.ASTNode.getChild (   self,
  args 
)

Python method signature(s):

getChild(ASTNode self, long n)   ASTNode

Get a child of this node according to its index number.

Parameters
nthe index of the child to get
Returns
the nth child of this ASTNode or None if this node has no nth child (n > ASTNode.getNumChildren() - 1).
def libsbml.ASTNode.getClass (   self)

Python method signature(s):

getClass(ASTNode self)   string

Get the class of this ASTNode.

Returns
the mathml class of this ASTNode.
def libsbml.ASTNode.getDefinitionURL (   self)

Python method signature(s):

getDefinitionURL(ASTNode self)   XMLAttributes

Gets the MathML definitionURL attribute value.

Returns
the value of the definitionURL attribute, in the form of a libSBML XMLAttributes object.
def libsbml.ASTNode.getDenominator (   self)

Python method signature(s):

getDenominator(ASTNode self)   long

Get the value of the denominator of this node. This function should be called only when ASTNode.getType() == AST_RATIONAL.

Returns
the value of the denominator of this ASTNode.
def libsbml.ASTNode.getExponent (   self)

Python method signature(s):

getExponent(ASTNode self)   long

Get the exponent value of this ASTNode. This function should be called only when ASTNode.getType() returns AST_REAL_E or AST_REAL.

Returns
the value of the exponent of this ASTNode.
def libsbml.ASTNode.getId (   self)

Python method signature(s):

getId(ASTNode self)   string

Get the id of this ASTNode.

Returns
the mathml id of this ASTNode.
def libsbml.ASTNode.getInteger (   self)

Python method signature(s):

getInteger(ASTNode self)   long

Get the value of this node as an integer. This function should be called only when ASTNode.getType() == AST_INTEGER.

Returns
the value of this ASTNode as a (long) integer.
def libsbml.ASTNode.getLeftChild (   self)

Python method signature(s):

getLeftChild(ASTNode self)   ASTNode

Get the left child of this node.

Returns
the left child of this ASTNode. This is equivalent to calling ASTNode.getChild() with an argument of 0.
def libsbml.ASTNode.getListOfNodes (   self)

Python method signature(s):

getListOfNodes(ASTNode self)   ASTNodeList

Performs a depth-first search of the tree rooted at this ASTNode object, and returns a List of nodes where the given function predicate(node) returns True (non-zero).

For portability between different programming languages, the predicate is passed in as a pointer to a function.

Parameters
predicatethe predicate to use
Returns
the list of nodes for which the predicate returned True (non-zero). The List returned is owned by the caller and should be deleted after the caller is done using it. The ASTNode objects in the list; however, are not owned by the caller (as they still belong to the tree itself), and therefore should not be deleted.
def libsbml.ASTNode.getMantissa (   self)

Python method signature(s):

getMantissa(ASTNode self)   float

Get the mantissa value of this node. This function should be called only when ASTNode.getType() returns AST_REAL_E or AST_REAL. If ASTNode.getType() returns AST_REAL, this method is identical to ASTNode.getReal().

Returns
the value of the mantissa of this ASTNode.
def libsbml.ASTNode.getName (   self)

getName(ASTNode self) string *

Get the value of this node as a string. This function may be called on nodes that (1) are not operators, i.e., nodes for which ASTNode.isOperator() returns False, and (2) are not numbers, i.e., ASTNode.isNumber() returns False.

Returns
the value of this ASTNode as a string.
def libsbml.ASTNode.getNumChildren (   self)

Python method signature(s):

getNumChildren(ASTNode self)   long

Get the number of children that this node has.

Returns
the number of children of this ASTNode, or 0 is this node has no children.
def libsbml.ASTNode.getNumerator (   self)

Python method signature(s):

getNumerator(ASTNode self)   long

Get the value of the numerator of this node. This function should be called only when ASTNode.getType() == AST_RATIONAL.

Returns
the value of the numerator of this ASTNode.
def libsbml.ASTNode.getNumSemanticsAnnotations (   self)

Python method signature(s):

getNumSemanticsAnnotations(ASTNode self)   long

Get the number of semantic annotation elements inside this node.

The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs.
Returns
the number of annotations of this ASTNode.
See Also
ASTNode.addSemanticsAnnotation()
def libsbml.ASTNode.getOperatorName (   self)

getOperatorName(ASTNode self) string *

Get the value of this operator node as a string. This function may be called on nodes that are operators, i.e., nodes for which ASTNode.isOperator() returns True.

Returns
the name of this operator ASTNode as a string (or None if not an operator).
def libsbml.ASTNode.getParentSBMLObject (   self)

Python method signature(s):

getParentSBMLObject(ASTNode self)   SBase

Returns the parent SBML object.

Returns
the parent SBML object of this ASTNode.
def libsbml.ASTNode.getPrecedence (   self)

Python method signature(s):

getPrecedence(ASTNode self)   int

Get the precedence of this node in the infix math syntax of SBML Level 1. For more information about the infix syntax, see the discussion about text string formulas at the top of the documentation for ASTNode.

Returns
an integer indicating the precedence of this ASTNode
def libsbml.ASTNode.getReal (   self)

Python method signature(s):

getReal(ASTNode self)   float

Get the real-numbered value of this node. This function should be called only when ASTNode.isReal() == true.

This function performs the necessary arithmetic if the node type is AST_REAL_E (mantissa * 10 exponent) or AST_RATIONAL (numerator / denominator).

Returns
the value of this ASTNode as a real (float).
def libsbml.ASTNode.getRightChild (   self)

Python method signature(s):

getRightChild(ASTNode self)   ASTNode

Get the right child of this node.

Returns
the right child of this ASTNode, or None if this node has no right child. If ASTNode.getNumChildren() > 1, then this is equivalent to:
1 getChild( getNumChildren() - 1 );
def libsbml.ASTNode.getSemanticsAnnotation (   self,
  args 
)

Python method signature(s):

getSemanticsAnnotation(ASTNode self, long n)   XMLNode

Get the nth semantic annotation of this node.

The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs.
Returns
the nth annotation of this ASTNode, or None if this node has no nth annotation (n > ASTNode.getNumChildren() - 1).
See Also
ASTNode.addSemanticsAnnotation()
def libsbml.ASTNode.getStyle (   self)

Python method signature(s):

getStyle(ASTNode self)   string

Get the style of this ASTNode.

Returns
the mathml style of this ASTNode.
def libsbml.ASTNode.getType (   self)

Python method signature(s):

getType(ASTNode self)   long

Get the type of this ASTNode. The value returned is one of the enumeration values such as AST_LAMBDA, AST_PLUS, etc.

Returns
the type of this ASTNode.
def libsbml.ASTNode.getUnits (   self)

Python method signature(s):

getUnits(ASTNode self)   string

Get the units of this ASTNode.

SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second:
<math xmlns="http://www.w3.org/1998/Math/MathML"
      xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
        <cn type="integer" sbml:units="second"> 10 </cn>
</math>
Returns
the units of this ASTNode.
Note
The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1–2 of SBML.
See Also
libsbml.parseL3Formula()
def libsbml.ASTNode.hasCorrectNumberArguments (   self)

Python method signature(s):

hasCorrectNumberArguments(ASTNode self)   bool

Predicate returning True or False depending on whether this ASTNode has the correct number of children for it's type.

For example, an ASTNode with type AST_PLUS expects 2 child nodes.

Note
This function performs a check on the toplevel node only. Child nodes are not checked.
Returns
True if this ASTNode is has appropriate number of children for it's type, False otherwise.
See Also
isWellFormedASTNode()
def libsbml.ASTNode.hasUnits (   self)

Python method signature(s):

hasUnits(ASTNode self)   bool

Predicate returning True (non-zero) if this node or any of its children nodes have the attribute sbml:units.

SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second:
<math xmlns="http://www.w3.org/1998/Math/MathML"
      xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
        <cn type="integer" sbml:units="second"> 10 </cn>
</math>
Returns
True if this ASTNode or its children has units associated with it, False otherwise.
Note
The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1–2 of SBML.
def libsbml.ASTNode.insertChild (   self,
  args 
)

Python method signature(s):

insertChild(ASTNode self, long n, ASTNode newChild)   int

Insert the given ASTNode at point n in the list of children of this ASTNode.

Parameters
nlong the index of the ASTNode being added
newChildASTNode to insert as the nth child
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Inserting a child into an ASTNode may change the structure of the mathematical formula being represented by the tree structure, and may render the representation invalid.
See Also
addChild()
prependChild()
replaceChild()
removeChild()
def libsbml.ASTNode.isAvogadro (   self)

Python method signature(s):

isAvogadro(ASTNode self)   bool

Predicate returning True (non-zero) if this node is the special symbol avogadro. The predicate returns False (zero) otherwise.

Returns
True if this ASTNode is the special symbol avogadro.
See Also
libsbml.parseL3Formula()
def libsbml.ASTNode.isBoolean (   self)

Python method signature(s):

isBoolean(ASTNode self)   bool

Predicate returning True (non-zero) if this node has a boolean type (a logical operator, a relational operator, or the constants True or False).

Returns
true if this ASTNode is a boolean, false otherwise.
def libsbml.ASTNode.isConstant (   self)

Python method signature(s):

isConstant(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents a MathML constant (e.g., True, Pi).

Returns
True if this ASTNode is a MathML constant, False otherwise.
Note
this function will also return True for AST_NAME_AVOGADRO in SBML Level 3.
def libsbml.ASTNode.isFunction (   self)

Python method signature(s):

isFunction(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents a MathML function (e.g., abs()), or an SBML Level 1 function, or a user-defined function.

Returns
True if this ASTNode is a function, False otherwise.
def libsbml.ASTNode.isInfinity (   self)

Python method signature(s):

isInfinity(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents the special IEEE 754 value infinity, False (zero) otherwise.

Returns
True if this ASTNode is the special IEEE 754 value infinity, False otherwise.
def libsbml.ASTNode.isInteger (   self)

Python method signature(s):

isInteger(ASTNode self)   bool

Predicate returning True (non-zero) if this node contains an integer value, False (zero) otherwise.

Returns
True if this ASTNode is of type AST_INTEGER, False otherwise.
def libsbml.ASTNode.isLambda (   self)

Python method signature(s):

isLambda(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a MathML <lambda>, False (zero) otherwise.

Returns
True if this ASTNode is of type AST_LAMBDA, False otherwise.
def libsbml.ASTNode.isLog10 (   self)

Python method signature(s):

isLog10(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents a log10 function, False (zero) otherwise. More precisely, this predicate returns True if the node type is AST_FUNCTION_LOG with two children, the first of which is an AST_INTEGER equal to 10.

Returns
True if the given ASTNode represents a log10() function, false otherwise.
See Also
libsbml.parseL3Formula()
def libsbml.ASTNode.isLogical (   self)

Python method signature(s):

isLogical(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a MathML logical operator (i.e., and, or, not, xor).

Returns
True if this ASTNode is a MathML logical operator
def libsbml.ASTNode.isName (   self)

Python method signature(s):

isName(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a user-defined variable name in SBML L1, L2 (MathML), or the special symbols delay or time. The predicate returns False (zero) otherwise.

Returns
True if this ASTNode is a user-defined variable name in SBML L1, L2 (MathML) or the special symbols delay or time.
def libsbml.ASTNode.isNaN (   self)

Python method signature(s):

isNaN(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents the special IEEE 754 value 'not a number' (NaN), False (zero) otherwise.

Returns
True if this ASTNode is the special IEEE 754 NaN.
def libsbml.ASTNode.isNegInfinity (   self)

Python method signature(s):

isNegInfinity(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents the special IEEE 754 value 'negative infinity', False (zero) otherwise.

Returns
True if this ASTNode is the special IEEE 754 value negative infinity, False otherwise.
def libsbml.ASTNode.isNumber (   self)

Python method signature(s):

isNumber(ASTNode self)   bool

Predicate returning True (non-zero) if this node contains a number, False (zero) otherwise. This is functionally equivalent to the following code:

1 isInteger() || isReal()
Returns
True if this ASTNode is a number, False otherwise.
def libsbml.ASTNode.isOperator (   self)

Python method signature(s):

isOperator(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a mathematical operator, meaning, +, -, *, / or ^ (power).

Returns
True if this ASTNode is an operator.
def libsbml.ASTNode.isPiecewise (   self)

Python method signature(s):

isPiecewise(ASTNode self)   bool

Predicate returning True (non-zero) if this node is the MathML <piecewise> construct, False (zero) otherwise.

Returns
True if this ASTNode is a MathML piecewise function
def libsbml.ASTNode.isRational (   self)

Python method signature(s):

isRational(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents a rational number, False (zero) otherwise.

Returns
True if this ASTNode is of type AST_RATIONAL.
def libsbml.ASTNode.isReal (   self)

Python method signature(s):

isReal(ASTNode self)   bool

Predicate returning True (non-zero) if this node can represent a real number, False (zero) otherwise. More precisely, this node must be of one of the following types: AST_REAL, AST_REAL_E or AST_RATIONAL.

Returns
True if the value of this ASTNode can represented as a real number, False otherwise.
def libsbml.ASTNode.isRelational (   self)

Python method signature(s):

isRelational(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a MathML relational operator, meaning ==, >=, >, <, and !=.

Returns
True if this ASTNode is a MathML relational operator, false otherwise
def libsbml.ASTNode.isSetClass (   self)

Python method signature(s):

isSetClass(ASTNode self)   bool

Predicate returning True (non-zero) if this node has the mathml attribute class.

Returns
true if this ASTNode has an attribute class, false otherwise.
def libsbml.ASTNode.isSetId (   self)

Python method signature(s):

isSetId(ASTNode self)   bool

Predicate returning True (non-zero) if this node has the mathml attribute id.

Returns
true if this ASTNode has an attribute id, false otherwise.
def libsbml.ASTNode.isSetStyle (   self)

Python method signature(s):

isSetStyle(ASTNode self)   bool

Predicate returning True (non-zero) if this node has the mathml attribute style.

Returns
true if this ASTNode has an attribute style, false otherwise.
def libsbml.ASTNode.isSetUnits (   self)

Python method signature(s):

isSetUnits(ASTNode self)   bool

Predicate returning True (non-zero) if this node has the attribute sbml:units.

SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second:
<math xmlns="http://www.w3.org/1998/Math/MathML"
      xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
        <cn type="integer" sbml:units="second"> 10 </cn>
</math>
Returns
True if this ASTNode has units associated with it, False otherwise.
Note
The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1–2 of SBML.
def libsbml.ASTNode.isSqrt (   self)

Python method signature(s):

isSqrt(ASTNode self)   bool

Predicate returning True (non-zero) if this node represents a square root function, False (zero) otherwise. More precisely, the node type must be AST_FUNCTION_ROOT with two children, the first of which is an AST_INTEGER node having value equal to 2.

Returns
True if the given ASTNode represents a sqrt() function, False otherwise.
def libsbml.ASTNode.isUMinus (   self)

Python method signature(s):

isUMinus(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a unary minus operator, False (zero) otherwise. A node is defined as a unary minus node if it is of type AST_MINUS and has exactly one child.

For numbers, unary minus nodes can be 'collapsed' by negating the number. In fact, libsbml.parseFormula() does this during its parsing process, and libsbml.parseL3Formula() has a configuration option that allows this behavior to be turned on or off. However, unary minus nodes for symbols (AST_NAME) cannot be 'collapsed', so this predicate function is necessary.

Returns
True if this ASTNode is a unary minus, False otherwise.
See Also
libsbml.parseL3Formula()
def libsbml.ASTNode.isUnknown (   self)

Python method signature(s):

isUnknown(ASTNode self)   bool

Predicate returning True (non-zero) if this node has an unknown type.

'Unknown' nodes have the type AST_UNKNOWN. Nodes with unknown types will not appear in an ASTNode tree returned by libSBML based upon valid SBML input; the only situation in which a node with type AST_UNKNOWN may appear is immediately after having create a new, untyped node using the ASTNode constructor. Callers creating nodes should endeavor to set the type to a valid node type as soon as possible after creating new nodes.

Returns
True if this ASTNode is of type AST_UNKNOWN, False otherwise.
def libsbml.ASTNode.isUPlus (   self)

Python method signature(s):

isUPlus(ASTNode self)   bool

Predicate returning True (non-zero) if this node is a unary plus operator, False (zero) otherwise. A node is defined as a unary minus node if it is of type AST_MINUS and has exactly one child.

Returns
True if this ASTNode is a unary plus, False otherwise.
def libsbml.ASTNode.isWellFormedASTNode (   self)

Python method signature(s):

isWellFormedASTNode(ASTNode self)   bool

Predicate returning True or False depending on whether this ASTNode is well-formed.

Note
An ASTNode may be well-formed, with each node and its children having the appropriate number of children for the given type, but may still be invalid in the context of its use within an SBML model.
Returns
True if this ASTNode is well-formed, False otherwise.
See Also
hasCorrectNumberArguments()
def libsbml.ASTNode.prependChild (   self,
  args 
)

Python method signature(s):

prependChild(ASTNode self, ASTNode child)   int

Adds the given node as a child of this ASTNode. This method adds child nodes from right to left.

Parameters
childthe ASTNode instance to add
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Prepending a child to an ASTNode may change the structure of the mathematical formula being represented by the tree structure, and may render the representation invalid.
See Also
addChild()
replaceChild()
insertChild()
removeChild()
def libsbml.ASTNode.reduceToBinary (   self)

Python method signature(s):

reduceToBinary(ASTNode self)

Reduces this ASTNode to a binary tree.

Example: if this ASTNode is and(x, y, z), then the formula of the reduced node is and(and(x, y), z). The operation replaces the formula stored in the current ASTNode object.

def libsbml.ASTNode.removeChild (   self,
  args 
)

Python method signature(s):

removeChild(ASTNode self, long n)   int

Removes the nth child of this ASTNode object.

Parameters
nlong the index of the child to remove
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Removing a child from an ASTNode may change the structure of the mathematical formula being represented by the tree structure, and may render the representation invalid.
See Also
addChild()
prependChild()
replaceChild()
insertChild()
def libsbml.ASTNode.renameSIdRefs (   self,
  args 
)

Python method signature(s):

renameSIdRefs(ASTNode self, string oldid, string newid)

Renames all the SIdRef attributes on this node and any child node

def libsbml.ASTNode.renameUnitSIdRefs (   self,
  args 
)

Python method signature(s):

renameUnitSIdRefs(ASTNode self, string oldid, string newid)

Renames all the UnitSIdRef attributes on this node and any child node. (The only place UnitSIDRefs appear in MathML <cn> elements.)

def libsbml.ASTNode.replaceArgument (   self,
  args 
)

Python method signature(s):

replaceArgument(ASTNode self, string bvar, ASTNode arg)

Replaces occurences of a given name within this ASTNode with the name/value/formula represented by arg.

For example, if the formula in this ASTNode is x + y, then the <bvar> is x and arg is an ASTNode representing the real value 3. This method substitutes 3 for x within this ASTNode object.

Parameters
bvara string representing the variable name to be substituted
argan ASTNode representing the name/value/formula to substitute
def libsbml.ASTNode.replaceChild (   self,
  args 
)

Python method signature(s):

replaceChild(ASTNode self, long n, ASTNode newChild)   int

Replaces the nth child of this ASTNode with the given ASTNode.

Parameters
nlong the index of the child to replace
newChildASTNode to replace the nth child
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Replacing a child from an ASTNode may change the structure of the mathematical formula being represented by the tree structure, and may render the representation invalid.
See Also
addChild()
prependChild()
insertChild()
removeChild()
def libsbml.ASTNode.returnsBoolean (   self,
  model = None 
)

Python method signature(s):

returnsBoolean(ASTNode self, Model model=None)   bool
returnsBoolean(ASTNode self)   bool

Predicate returning True (non-zero) if this node returns a boolean type or False (zero) otherwise.

This function looks at the whole ASTNode rather than just the top level of the ASTNode. Thus it will consider return values from piecewise statements. In addition, if this ASTNode uses a function call, the return value of the functionDefinition will be determined. Note that this is only possible where the ASTNode can trace its parent Model, that is, the ASTNode must represent the math element of some SBML object that has already been added to an instance of an SBMLDocument.

See Also
isBoolean()
Returns
true if this ASTNode returns a boolean, false otherwise.
def libsbml.ASTNode.setCharacter (   self,
  args 
)

Python method signature(s):

setCharacter(ASTNode self, char value)   int

Sets the value of this ASTNode to the given character. If character is one of +, -, *, / or ^, the node type will be set accordingly. For all other characters, the node type will be set to AST_UNKNOWN.

Parameters
valuethe character value to which the node's value should be set.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setClass (   self,
  args 
)

Python method signature(s):

setClass(ASTNode self, string className)   int

Sets the mathml class of this ASTNode to className.

Parameters
classNamestring representing the mathml class for this node.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setId (   self,
  args 
)

Python method signature(s):

setId(ASTNode self, string id)   int

Sets the mathml id of this ASTNode to id.

Parameters
idstring representing the identifier.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setName (   self,
  args 
)

setName(ASTNode self, char * name) int

Sets the value of this ASTNode to the given name.

As a side-effect, this ASTNode object's type will be reset to AST_NAME if (and only if) the ASTNode was previously an operator ( ASTNode.isOperator() == true), number ( ASTNode.isNumber() == true), or unknown. This allows names to be set for AST_FUNCTION nodes and the like.

Parameters
namethe string containing the name to which this node's value should be set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setStyle (   self,
  args 
)

Python method signature(s):

setStyle(ASTNode self, string style)   int

Sets the mathml style of this ASTNode to style.

Parameters
stylestring representing the identifier.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setType (   self,
  args 
)

Python method signature(s):

setType(ASTNode self, long type)   int

Sets the type of this ASTNode to the given type code. A side-effect of doing this is that any numerical values previously stored in this node are reset to zero.

Parameters
typethe type to which this node should be set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.setUnits (   self,
  args 
)

Python method signature(s):

setUnits(ASTNode self, string units)   int

Sets the units of this ASTNode to units.

The units will be set only if this ASTNode object represents a MathML <cn> element, i.e., represents a number. Callers may use ASTNode.isNumber() to inquire whether the node is of that type.

SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second:
<math xmlns="http://www.w3.org/1998/Math/MathML"
      xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
        <cn type="integer" sbml:units="second"> 10 </cn>
</math>
Parameters
unitsstring representing the unit identifier.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1–2 of SBML.
def libsbml.ASTNode.setValue (   self,
  args 
)

Python method signature(s):

setValue(ASTNode self, long value)   int
setValue(ASTNode self, long numerator, long denominator)   int
setValue(ASTNode self, float value)   int
setValue(ASTNode self, float mantissa, long exponent)   int

This method has multiple variants that differ in the arguments they accept. Each is described separately below.


Method variant with the following signature:

setValue(long numerator, long denominator)

Sets the value of this ASTNode to the given rational in two parts: the numerator and denominator. The node type is set to AST_RATIONAL.

Parameters
numeratorthe numerator value of the rational
denominatorthe denominator value of the rational
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Method variant with the following signature:
setValue (float mantissa, long exponent)

Sets the value of this ASTNode to the given real (float) in two parts: the mantissa and the exponent. The node type is set to AST_REAL_E.

Parameters
mantissathe mantissa of this node's real-numbered value
exponentthe exponent of this node's real-numbered value
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Method variant with the following signature:
setValue(int value)

Sets the value of this ASTNode to the given integer and sets the node type to AST_INTEGER.

Parameters
valuethe integer to which this node's value should be set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Method variant with the following signature:
setValue (float value)

Sets the value of this ASTNode to the given real (float) and sets the node type to AST_REAL.

This is functionally equivalent to:

1 setValue(value, 0);
Parameters
valuethe float format number to which this node's value should be set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Method variant with the following signature:
setValue(long value)

Sets the value of this ASTNode to the given (long) integer and sets the node type to AST_INTEGER.

Parameters
valuethe integer to which this node's value should be set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.swapChildren (   self,
  args 
)

Python method signature(s):

swapChildren(ASTNode self, ASTNode that)   int

Swap the children of this ASTNode object with the children of the given ASTNode object.

Parameters
thatthe other node whose children should be used to replace this node's children
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.unsetClass (   self)

Python method signature(s):

unsetClass(ASTNode self)   int

Unsets the mathml class of this ASTNode.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.unsetId (   self)

Python method signature(s):

unsetId(ASTNode self)   int

Unsets the mathml id of this ASTNode.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.unsetStyle (   self)

Python method signature(s):

unsetStyle(ASTNode self)   int

Unsets the mathml style of this ASTNode.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
def libsbml.ASTNode.unsetUnits (   self)

Python method signature(s):

unsetUnits(ASTNode self)   int

Unsets the units of this ASTNode.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are: