getRightChild() public method

public getRightChild ( ) : ASTNode
return ASTNode
    /**
     *
     * Creates an SBML model represented in "7.2 Example involving units"
     * in the SBML Level 2 Version 4 Specification.
     *
     */
    private static SBMLDocument createExampleInvolvingUnits()
    {
        int level = Level;
        int version = Version;

        //---------------------------------------------------------------------------
        //
        // Creates an SBMLDocument object
        //
        //---------------------------------------------------------------------------

        SBMLDocument sbmlDoc = new SBMLDocument(level, version);

        // Adds the namespace for XHTML to the SBMLDocument object.  We need this
        // because we will add notes to the model.  (By default, the SBML document
        // created by SBMLDocument only declares the SBML XML namespace.)

        sbmlDoc.getNamespaces().add("http://www.w3.org/1999/xhtml", "xhtml");

        //---------------------------------------------------------------------------
        //
        // Creates a Model object inside the SBMLDocument object.
        //
        //---------------------------------------------------------------------------

        Model model = sbmlDoc.createModel();
        model.setId("unitsExample");

        //---------------------------------------------------------------------------
        //
        // Creates UnitDefinition objects inside the Model object.
        //
        //---------------------------------------------------------------------------

        // Temporary pointers (reused more than once below).

        UnitDefinition unitdef;
        Unit unit;

        //---------------------------------------------------------------------------
        // (UnitDefinition1) Creates an UnitDefinition object ("substance").
        //
        // This has the effect of redefining the default unit of subtance for the
        // whole model.
        //---------------------------------------------------------------------------

        unitdef = model.createUnitDefinition();
        unitdef.setId("substance");

        //  Creates an Unit inside the UnitDefinition object

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_MOLE);
        unit.setScale(-3);

        //--------------------------------------------------------------------------------
        // (UnitDefinition2) Creates an UnitDefinition object ("mmls")
        //--------------------------------------------------------------------------------

        // Note that we can reuse the pointers 'unitdef' and 'unit' because the
        // actual UnitDefinition object (along with the Unit objects within it)
        // is already attached to the Model object.

        unitdef = model.createUnitDefinition();
        unitdef.setId("mmls");

        //  Creates an Unit inside the UnitDefinition object ("mmls")

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_MOLE);
        unit.setScale(-3);

        //  Creates an Unit inside the UnitDefinition object ("mmls")

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_LITRE);
        unit.setExponent(-1);

        //  Creates an Unit inside the UnitDefinition object ("mmls")

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_SECOND);
        unit.setExponent(-1);

        //--------------------------------------------------------------------------------
        // (UnitDefinition3) Creates an UnitDefinition object ("mml")
        //--------------------------------------------------------------------------------

        unitdef = model.createUnitDefinition();
        unitdef.setId("mml");

        //  Creates an Unit inside the UnitDefinition object ("mml")

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_MOLE);
        unit.setScale(-3);

        //  Creates an Unit inside the UnitDefinition object ("mml")

        unit = unitdef.createUnit();
        unit.setKind(libsbml.UNIT_KIND_LITRE);
        unit.setExponent(-1);

        //---------------------------------------------------------------------------
        //
        // Creates a Compartment object inside the Model object.
        //
        //---------------------------------------------------------------------------

        Compartment comp;
        string compName = "cell";

        // Creates a Compartment object ("cell")

        comp = model.createCompartment();
        comp.setId(compName);

        // Sets the "size" attribute of the Compartment object.
        //
        //   The units of this Compartment object is the default SBML
        //   units of volume (litre), and thus we don't have to explicitly invoke
        //   setUnits("litre") function to set the default units.
        //
        comp.setSize(1);

        //---------------------------------------------------------------------------
        //
        // Creates Species objects inside the Model object.
        //
        //---------------------------------------------------------------------------

        // Temporary pointer (reused more than once below).

        Species sp;

        //---------------------------------------------------------------------------
        // (Species1) Creates a Species object ("x0")
        //---------------------------------------------------------------------------

        sp = model.createSpecies();
        sp.setId("x0");

        // Sets the "compartment" attribute of the Species object to identify the
        // compartnet in which the Species object located.

        sp.setCompartment(compName);

        // Sets the "initialConcentration" attribute of the Species object.
        //
        //  The units of this Species object is determined by two attributes of this
        //  Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the
        //  "spatialDimensions" attribute of the Compartment object ("cytosol") in which
        //  this species object is located.
        //  Since the default values are used for "substanceUnits" (substance (mole))
        //  and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3)
        //  is greater than 0, the units of this Species object is  moles/liters .
        //
        sp.setInitialConcentration(1);

        //---------------------------------------------------------------------------
        // (Species2) Creates a Species object ("x1")
        //---------------------------------------------------------------------------

        sp = model.createSpecies();
        sp.setId("x1");
        sp.setCompartment(compName);
        sp.setInitialConcentration(1);

        //---------------------------------------------------------------------------
        // (Species3) Creates a Species object ("s1")
        //---------------------------------------------------------------------------

        sp = model.createSpecies();
        sp.setCompartment(compName);
        sp.setId("s1");
        sp.setInitialConcentration(1);

        //---------------------------------------------------------------------------
        // (Species4) Creates a Species object ("s2")
        //---------------------------------------------------------------------------

        sp = model.createSpecies();
        sp.setCompartment(compName);
        sp.setId("s2");
        sp.setInitialConcentration(1);

        //---------------------------------------------------------------------------
        //
        // Creates global Parameter objects inside the Model object.
        //
        //---------------------------------------------------------------------------

        Parameter para;

        // Creates a Parameter ("vm")

        para = model.createParameter();
        para.setId("vm");
        para.setValue(2);
        para.setUnits("mmls");

        // Creates a Parameter ("km")

        para = model.createParameter();
        para.setId("km");
        para.setValue(2);
        para.setUnits("mml");

        //---------------------------------------------------------------------------
        //
        // Creates Reaction objects inside the Model object.
        //
        //---------------------------------------------------------------------------

        // Temporary pointers.

        Reaction reaction;
        SpeciesReference spr;
        KineticLaw kl;

        //---------------------------------------------------------------------------
        // (Reaction1) Creates a Reaction object ("v1").
        //---------------------------------------------------------------------------

        reaction = model.createReaction();
        reaction.setId("v1");

        //---------------------------------------------------------------------------
        // Creates Reactant objects inside the Reaction object ("v1").
        //---------------------------------------------------------------------------

        // (Reactant1) Creates a Reactant object that references Species "x0"
        // in the model.

        spr = reaction.createReactant();
        spr.setSpecies("x0");

        //---------------------------------------------------------------------------
        // Creates a Product object inside the Reaction object ("v1").
        //---------------------------------------------------------------------------

        // Creates a Product object that references Species "s1" in the model.

        spr = reaction.createProduct();
        spr.setSpecies("s1");

        //---------------------------------------------------------------------------
        // Creates a KineticLaw object inside the Reaction object ("v1").
        //---------------------------------------------------------------------------

        kl = reaction.createKineticLaw();

        // Creates a <notes> element in the KineticLaw object.
        // Here we illustrate how to do it using a literal string.  This requires
        // known the required syntax of XHTML and the requirements for SBML <notes>
        // elements.  Later below, we show how to create notes using objects instead
        // of strings.

        string notesString = "<xhtml:p> ((vm * s1)/(km + s1)) * cell </xhtml:p>";
        kl.setNotes(notesString);

        //---------------------------------------------------------------------------
        // Creates an ASTNode object which represents the following KineticLaw object.
        //
        //  <math xmlns=\"http://www.w3.org/1998/Math/MathML\">
        //   <apply>
        //     <times/>
        //     <apply>
        //       <divide/>
        //       <apply>
        //         <times/>
        //           <ci> vm </ci>
        //           <ci> s1 </ci>
        //       </apply>
        //       <apply>
        //         <plus/>
        //           <ci> km </ci>
        //           <ci> s1 </ci>
        //       </apply>
        //     </apply>
        //     <ci> cell </ci>
        //    </apply>
        //  </math>
        //---------------------------------------------------------------------------

        //
        // In the following code, ASTNode objects, which construct an ASTNode tree
        // of the above math, are created and added in the order of preorder traversal
        // of the tree (i.e. the order corresponds to the nested structure of the above
        // MathML elements), and thus the following code maybe a bit more efficient but
        // maybe a bit difficult to read.
        //

        ASTNode astMath = new ASTNode(libsbml.AST_TIMES);

        astMath.addChild(new ASTNode(libsbml.AST_DIVIDE));
        ASTNode astDivide = astMath.getLeftChild();

        astDivide.addChild(new ASTNode(libsbml.AST_TIMES));
        ASTNode astTimes = astDivide.getLeftChild();

        astTimes.addChild(new ASTNode(libsbml.AST_NAME));
        astTimes.getLeftChild().setName("vm");

        astTimes.addChild(new ASTNode(libsbml.AST_NAME));
        astTimes.getRightChild().setName("s1");

        astDivide.addChild(new ASTNode(libsbml.AST_PLUS));
        ASTNode astPlus = astDivide.getRightChild();

        astPlus.addChild(new ASTNode(libsbml.AST_NAME));
        astPlus.getLeftChild().setName("km");

        astPlus.addChild(new ASTNode(libsbml.AST_NAME));
        astPlus.getRightChild().setName("s1");

        astMath.addChild(new ASTNode(libsbml.AST_NAME));
        astMath.getRightChild().setName("cell");

        //---------------------------------------------
        //
        // set the Math element
        //
        //------------------------------------------------

        kl.setMath(astMath);

        //---------------------------------------------------------------------------
        // (Reaction2) Creates a Reaction object ("v2").
        //---------------------------------------------------------------------------

        reaction = model.createReaction();
        reaction.setId("v2");

        //---------------------------------------------------------------------------
        // Creates Reactant objects inside the Reaction object ("v2").
        //---------------------------------------------------------------------------

        // (Reactant2) Creates a Reactant object that references Species "s1"
        // in the model.

        spr = reaction.createReactant();
        spr.setSpecies("s1");

        //---------------------------------------------------------------------------
        // Creates a Product object inside the Reaction object ("v2").
        //---------------------------------------------------------------------------

        // Creates a Product object that references Species "s2" in the model.

        spr = reaction.createProduct();
        spr.setSpecies("s2");

        //---------------------------------------------------------------------------
        // Creates a KineticLaw object inside the Reaction object ("v2").
        //---------------------------------------------------------------------------

        kl = reaction.createKineticLaw();

        // Sets a notes (by XMLNode) to the KineticLaw object.
        //
        // The following code is an alternative to using setNotes(const string&).
        // The equivalent code would be like this:
        //
        //     notesString = "<xhtml:p>((vm * s2)/(km + s2))*cell</xhtml:p>";
        //     kl.setNotes(notesString);

        // Creates an XMLNode of start element (<xhtml:p>) without attributes.

        XMLNode notesXMLNode = new XMLNode(
            new XMLTriple("p", "", "xhtml"),
            new XMLAttributes());

        // Adds a text element to the start element.

        notesXMLNode.addChild(new XMLNode(" ((vm * s2)/(km + s2)) * cell "));

        // Adds it to the kineticLaw object.

        kl.setNotes(notesXMLNode);

        //---------------------------------------------------------------------------
        // Sets a math (ASTNode object) to the KineticLaw object.
        //---------------------------------------------------------------------------

        // To create mathematical expressions, one would typically construct
        // an ASTNode tree as the above example code which creates a math of another
        // KineticLaw object.  Here, to save some space and illustrate another approach
        // of doing it, we will write out the formula in MathML form and then use a
        // libSBML convenience function to create the ASTNode tree for us.
        // (This is a bit dangerous; it's very easy to make mistakes when writing MathML
        // by hand, so in a real program, we would not really want to do it this way.)

        string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
        + "  <apply>"
        + "    <times/>"
        + "    <apply>"
        + "      <divide/>"
        + "      <apply>"
        + "        <times/>"
        + "        <ci> vm </ci>"
        + "        <ci> s2 </ci>"
        + "      </apply>"
        + "      <apply>"
        + "        <plus/>"
        + "          <ci> km </ci>"
        + "          <ci> s2 </ci>"
        + "      </apply>"
        + "    </apply>"
        + "    <ci> cell </ci>"
        + "  </apply>"
        + "</math>";

        astMath = libsbml.readMathMLFromString(mathXMLString);
        kl.setMath(astMath);

        //---------------------------------------------------------------------------
        // (Reaction3) Creates a Reaction object ("v3").
        //---------------------------------------------------------------------------

        reaction = model.createReaction();
        reaction.setId("v3");

        //---------------------------------------------------------------------------
        // Creates Reactant objects inside the Reaction object ("v3").
        //---------------------------------------------------------------------------

        // (Reactant2) Creates a Reactant object that references Species "s2"
        // in the model.

        spr = reaction.createReactant();
        spr.setSpecies("s2");

        //---------------------------------------------------------------------------
        // Creates a Product object inside the Reaction object ("v3").
        //---------------------------------------------------------------------------

        // Creates a Product object that references Species "x1" in the model.

        spr = reaction.createProduct();
        spr.setSpecies("x1");

        //---------------------------------------------------------------------------
        // Creates a KineticLaw object inside the Reaction object ("v3").
        //---------------------------------------------------------------------------

        kl = reaction.createKineticLaw();

        // Sets a notes (by string) to the KineticLaw object.

        notesString = "<xhtml:p> ((vm * x1)/(km + x1)) * cell </xhtml:p>";
        kl.setNotes(notesString);

        //---------------------------------------------------------------------------
        // Sets a math (ASTNode object) to the KineticLaw object.
        //---------------------------------------------------------------------------

        mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
        + "  <apply>"
        + "    <times/>"
        + "    <apply>"
        + "      <divide/>"
        + "      <apply>"
        + "        <times/>"
        + "        <ci> vm </ci>"
        + "        <ci> x1 </ci>"
        + "      </apply>"
        + "      <apply>"
        + "        <plus/>"
        + "          <ci> km </ci>"
        + "          <ci> x1 </ci>"
        + "      </apply>"
        + "    </apply>"
        + "    <ci> cell </ci>"
        + "  </apply>"
        + "</math>";

        astMath = libsbml.readMathMLFromString(mathXMLString);
        kl.setMath(astMath);

        // Returns the created SBMLDocument object.
        // The returned object must be explicitly deleted by the caller,
        // otherwise memory leak will happen.

        return sbmlDoc;
    }
Ejemplo n.º 2
0
 public void test_element_bug_csymbol_1()
 {
     string s = wrapMathML("<apply>" +
     "  <gt/>" +
     "  <csymbol encoding='text' " +
     "    definitionURL='http://www.sbml.org/sbml/symbols/time'>time</csymbol>" +
     "  <cn>5000</cn>" +
     "</apply>");
       N = libsbml.readMathMLFromString(s);
       assertTrue( N != null );
       assertTrue( N.getType() == libsbml.AST_RELATIONAL_GT );
       assertTrue( N.getNumChildren() == 2 );
       ASTNode c = N.getLeftChild();
       assertTrue( c != null );
       assertTrue( c.getType() == libsbml.AST_NAME_TIME );
       assertTrue((  "time" == c.getName() ));
       assertTrue( c.getNumChildren() == 0 );
       c = N.getRightChild();
       assertTrue( c != null );
       assertTrue( c.getType() == libsbml.AST_REAL );
       assertTrue( c.getReal() == 5000 );
       assertTrue( c.getNumChildren() == 0 );
 }
Ejemplo n.º 3
0
 public void test_element_bug_csymbol_delay_1()
 {
     string s = wrapMathML("<apply>" +
     "  <csymbol encoding='text' definitionURL='http://www.sbml.org/sbml/" +
     "symbols/delay'> my_delay </csymbol>" +
     "  <ci> x </ci>" +
     "  <cn> 0.1 </cn>" +
     "</apply>\n");
       N = libsbml.readMathMLFromString(s);
       assertTrue( N != null );
       assertTrue( N.getType() == libsbml.AST_FUNCTION_DELAY );
       assertTrue((  "my_delay" == N.getName() ));
       assertTrue( N.getNumChildren() == 2 );
       ASTNode c = N.getLeftChild();
       assertTrue( c != null );
       assertTrue( c.getType() == libsbml.AST_NAME );
       assertTrue((  "x" == c.getName() ));
       assertTrue( c.getNumChildren() == 0 );
       c = N.getRightChild();
       assertTrue( c != null );
       assertTrue( c.getType() == libsbml.AST_REAL );
       assertTrue( c.getReal() == 0.1 );
       assertTrue( c.getNumChildren() == 0 );
 }
Ejemplo n.º 4
0
 public void test_ASTNode_one_child()
 {
     ASTNode node = new  ASTNode();
       ASTNode child = new  ASTNode();
       node.addChild(child);
       assertTrue( node.getNumChildren() == 1 );
       assertTrue( node.getLeftChild() == child );
       assertTrue( node.getRightChild() == null );
       assertTrue( node.getChild(0) == child );
       assertTrue( node.getChild(1) == null );
       node = null;
 }
Ejemplo n.º 5
0
 public void test_ASTNode_no_children()
 {
     ASTNode node = new  ASTNode();
       assertTrue( node.getNumChildren() == 0 );
       assertTrue( node.getLeftChild() == null );
       assertTrue( node.getRightChild() == null );
       assertTrue( node.getChild(0) == null );
       node = null;
 }
Ejemplo n.º 6
0
 public void test_ASTNode_deepCopy_1()
 {
     ASTNode node = new  ASTNode();
       ASTNode child, copy;
       node.setCharacter( '+');
       node.addChild(new  ASTNode());
       node.addChild(new  ASTNode());
       node.getLeftChild().setValue(1);
       node.getRightChild().setValue(2);
       assertTrue( node.getType() == libsbml.AST_PLUS );
       assertTrue( node.getCharacter() == '+' );
       assertTrue( node.getNumChildren() == 2 );
       child = node.getLeftChild();
       assertTrue( child.getType() == libsbml.AST_INTEGER );
       assertTrue( child.getInteger() == 1 );
       assertTrue( child.getNumChildren() == 0 );
       child = node.getRightChild();
       assertTrue( child.getType() == libsbml.AST_INTEGER );
       assertTrue( child.getInteger() == 2 );
       assertTrue( child.getNumChildren() == 0 );
       copy = node.deepCopy();
       assertTrue( copy != node );
       assertTrue( copy.getType() == libsbml.AST_PLUS );
       assertTrue( copy.getCharacter() == '+' );
       assertTrue( copy.getNumChildren() == 2 );
       child = copy.getLeftChild();
       assertTrue( child != node.getLeftChild() );
       assertTrue( child.getType() == libsbml.AST_INTEGER );
       assertTrue( child.getInteger() == 1 );
       assertTrue( child.getNumChildren() == 0 );
       child = copy.getRightChild();
       assertTrue( child != node.getRightChild() );
       assertTrue( child.getType() == libsbml.AST_INTEGER );
       assertTrue( child.getInteger() == 2 );
       assertTrue( child.getNumChildren() == 0 );
       node = null;
       copy = null;
 }
Ejemplo n.º 7
0
 public void test_ASTNode_children()
 {
     ASTNode parent = new  ASTNode();
       ASTNode left = new  ASTNode();
       ASTNode right = new  ASTNode();
       ASTNode right2 = new  ASTNode();
       parent.setType(libsbml.AST_PLUS);
       left.setValue(1);
       right.setValue(2);
       right2.setValue(3);
       parent.addChild(left);
       parent.addChild(right);
       assertTrue( parent.getNumChildren() == 2 );
       assertTrue( left.getNumChildren() == 0 );
       assertTrue( right.getNumChildren() == 0 );
       assertTrue( parent.getLeftChild() == left );
       assertTrue( parent.getRightChild() == right );
       assertTrue( parent.getChild(0) == left );
       assertTrue( parent.getChild(1) == right );
       assertTrue( parent.getChild(2) == null );
       parent.addChild(right2);
       assertTrue( parent.getNumChildren() == 3 );
       assertTrue( left.getNumChildren() == 0 );
       assertTrue( right.getNumChildren() == 0 );
       assertTrue( right2.getNumChildren() == 0 );
       assertTrue( parent.getLeftChild() == left );
       assertTrue( parent.getRightChild() == right2 );
       assertTrue( parent.getChild(0) == left );
       assertTrue( parent.getChild(1) == right );
       assertTrue( parent.getChild(2) == right2 );
       assertTrue( parent.getChild(3) == null );
       parent = null;
 }
Ejemplo n.º 8
0
 public void test_ASTNode_canonicalizeFunctionsL1()
 {
     ASTNode n = new  ASTNode(libsbml.AST_FUNCTION);
       ASTNode c;
       n.setName( "acos");
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOS );
       n.setType(libsbml.AST_FUNCTION);
       n.setName( "asin");
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSIN );
       n.setType(libsbml.AST_FUNCTION);
       n.setName( "atan");
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCTAN );
       n.setType(libsbml.AST_FUNCTION);
       n.setName( "ceil");
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_CEILING );
       n.setType(libsbml.AST_FUNCTION);
       n.setName( "pow");
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_POWER );
       n = null;
       n = new  ASTNode(libsbml.AST_FUNCTION);
       n.setName( "log");
       c = new  ASTNode();
       c.setName( "x");
       n.addChild(c);
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       assertTrue( n.getNumChildren() == 1 );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_LN );
       assertTrue( n.getNumChildren() == 1 );
       n.setType(libsbml.AST_FUNCTION);
       c = new  ASTNode();
       c.setName( "y");
       n.addChild(c);
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       assertTrue( n.getNumChildren() == 2 );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_LOG );
       n = null;
       n = new  ASTNode(libsbml.AST_FUNCTION);
       n.setName( "log10");
       c = new  ASTNode();
       c.setName( "x");
       n.addChild(c);
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       assertTrue( n.getNumChildren() == 1 );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_LOG );
       assertTrue( n.getNumChildren() == 2 );
       c = n.getLeftChild();
       assertTrue( c.getType() == libsbml.AST_INTEGER );
       assertTrue( c.getInteger() == 10 );
       c = n.getRightChild();
       assertTrue( c.getType() == libsbml.AST_NAME );
       assertTrue((  "x" == c.getName() ));
       n = null;
       n = new  ASTNode(libsbml.AST_FUNCTION);
       n.setName( "sqr");
       c = new  ASTNode();
       c.setName( "x");
       n.addChild(c);
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       assertTrue( n.getNumChildren() == 1 );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_POWER );
       assertTrue( n.getNumChildren() == 2 );
       c = n.getLeftChild();
       assertTrue( c.getType() == libsbml.AST_NAME );
       assertTrue((  "x" == c.getName() ));
       c = n.getRightChild();
       assertTrue( c.getType() == libsbml.AST_INTEGER );
       assertTrue( c.getInteger() == 2 );
       n = null;
       n = new  ASTNode(libsbml.AST_FUNCTION);
       n.setName( "sqrt");
       c = new  ASTNode();
       c.setName( "x");
       n.addChild(c);
       assertTrue( n.getType() == libsbml.AST_FUNCTION );
       assertTrue( n.getNumChildren() == 1 );
       n.canonicalize();
       assertTrue( n.getType() == libsbml.AST_FUNCTION_ROOT );
       assertTrue( n.getNumChildren() == 2 );
       c = n.getLeftChild();
       assertTrue( c.getType() == libsbml.AST_INTEGER );
       assertTrue( c.getInteger() == 2 );
       c = n.getRightChild();
       assertTrue( c.getType() == libsbml.AST_NAME );
       assertTrue((  "x" == c.getName() ));
       n = null;
 }