public void test_InitialAssignment_setMath2() { ASTNode math = new ASTNode(libsbml.AST_DIVIDE); int i = E.setMath(math); assertTrue( i == libsbml.LIBSBML_INVALID_OBJECT ); assertEquals( false, E.isSetMath() ); math = null; }
public void test_Constraint_setMath2() { ASTNode math = new ASTNode(libsbml.AST_TIMES); int i = C.setMath(math); assertTrue( i == libsbml.LIBSBML_INVALID_OBJECT ); assertEquals( false, C.isSetMath() ); math = null; }
public void test_ValidASTNode_binary() { ASTNode n = new ASTNode(libsbml.AST_DIVIDE); assertEquals( false, (n.isWellFormedASTNode()) ); ASTNode c = libsbml.parseFormula("c"); n.addChild(c); assertEquals( false, (n.isWellFormedASTNode()) ); ASTNode d = libsbml.parseFormula("d"); n.addChild(d); assertEquals( true, n.isWellFormedASTNode() ); n = null; }
public void test_ASTNode_addSemanticsAnnotation() { XMLNode ann = new XMLNode(); ASTNode node = new ASTNode(); int i = 0; i = node.addSemanticsAnnotation(ann); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertTrue( node.getNumSemanticsAnnotations() == 1 ); i = node.addSemanticsAnnotation(null); assertTrue( i == libsbml.LIBSBML_OPERATION_FAILED ); assertTrue( node.getNumSemanticsAnnotations() == 1 ); node = null; }
public void test_ValidASTNode_lambda() { ASTNode n = new ASTNode(libsbml.AST_LAMBDA); assertEquals( false, (n.isWellFormedASTNode()) ); ASTNode c = libsbml.parseFormula("c"); n.addChild(c); assertEquals( true, n.isWellFormedASTNode() ); ASTNode d = libsbml.parseFormula("d"); n.addChild(d); assertEquals( true, n.isWellFormedASTNode() ); ASTNode e = libsbml.parseFormula("e"); n.addChild(e); assertEquals( true, n.isWellFormedASTNode() ); n = null; }
public void test_Rule_setMath1() { ASTNode math = new ASTNode(libsbml.AST_TIMES); ASTNode a = new ASTNode(); ASTNode b = new ASTNode(); a.setName( "a"); b.setName( "b"); math.addChild(a); math.addChild(b); string formula; ASTNode math1; int i = R.setMath(math); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertEquals( true, R.isSetMath() ); math1 = R.getMath(); assertTrue( math1 != null ); formula = libsbml.formulaToString(math1); assertTrue( formula != null ); assertTrue(( "a * b" == formula )); math = null; }
public void test_ASTNode_addChild1() { ASTNode node = new ASTNode(); ASTNode c1 = new ASTNode(); ASTNode c2 = new ASTNode(); ASTNode c1_1 = new ASTNode(); int i = 0; node.setType(libsbml.AST_LOGICAL_AND); c1.setName( "a"); c2.setName( "b"); node.addChild(c1); node.addChild(c2); assertTrue( node.getNumChildren() == 2 ); assertTrue(( "and(a, b)" == libsbml.formulaToString(node) )); c1_1.setName( "d"); i = node.addChild(c1_1); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertTrue( node.getNumChildren() == 3 ); assertTrue(( "and(a, b, d)" == libsbml.formulaToString(node) )); assertTrue(( "a" == node.getChild(0).getName() )); assertTrue(( "b" == node.getChild(1).getName() )); assertTrue(( "d" == node.getChild(2).getName() )); node = null; }
/** */ /* libsbml-internal */ public new void multiplyAssignmentsToSIdByFunction(string id, ASTNode function) { libsbmlPINVOKE.KineticLaw_multiplyAssignmentsToSIdByFunction(swigCPtr, id, ASTNode.getCPtr(function)); if (libsbmlPINVOKE.SWIGPendingException.Pending) throw libsbmlPINVOKE.SWIGPendingException.Retrieve(); }
/** * Sets the mathematical expression of this KineticLaw instance to a copy * of the given ASTNode. * * This is fundamentally identical to * @if java KineticLaw::setFormula(String formula)@else getFormula()@endif. * The latter is provided principally for compatibility compatibility with * SBML Level 1, which represented mathematical formulas in text-string * form. * * @param math an ASTNode representing a formula tree. * * * * @return integer value indicating success/failure of the * function. @if clike The value is drawn from the * enumeration #OperationReturnValues_t. @endif The possible values * returned by this function are: * * * @li @link libsbml#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS@endlink * @li @link libsbml#LIBSBML_INVALID_OBJECT LIBSBML_INVALID_OBJECT@endlink * * @see setFormula(string formula) */ public int setMath(ASTNode math) { int ret = libsbmlPINVOKE.KineticLaw_setMath(swigCPtr, ASTNode.getCPtr(math)); return ret; }
/** * Sets the 'math' subelement of this FunctionDefinition to the Abstract * Syntax Tree given in @p math. * * @param math an AST containing the mathematical expression to * be used as the formula for this FunctionDefinition. * * @return integer value indicating success/failure of the * function. @if clike The value is drawn from the * enumeration #OperationReturnValues_t. @endif The possible values * returned by this function are: * @li @link libsbmlcs#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS@endlink * @li @link libsbmlcs#LIBSBML_INVALID_OBJECT LIBSBML_INVALID_OBJECT@endlink */ public int setMath(ASTNode math) { int ret = libsbmlPINVOKE.FunctionDefinition_setMath(swigCPtr, ASTNode.getCPtr(math)); return ret; }
/** * Sets the 'math' subelement of this InitialAssignment. * * The AST passed in @p math is copied. * * @param math an AST containing the mathematical expression to * be used as the formula for this InitialAssignment. * * @return integer value indicating success/failure of the * function. The possible values * returned by this function are: * @li @link libsbmlcs.libsbml.LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS @endlink * @li @link libsbmlcs.libsbml.LIBSBML_INVALID_OBJECT LIBSBML_INVALID_OBJECT @endlink */ public int setMath(ASTNode math) { int ret = libsbmlPINVOKE.InitialAssignment_setMath(swigCPtr, ASTNode.getCPtr(math)); return ret; }
public void test_element_neq() { string s = wrapMathML("<apply> <neq/> <notanumber/> <notanumber/> </apply>" ); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "neq(NaN, NaN)" == F )); }
public void test_ValidASTNode_setType() { ASTNode n = new ASTNode(); int i = n.setType(libsbml.AST_REAL); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertTrue( n.getType() == libsbml.AST_REAL ); i = n.setType(libsbml.AST_PLUS); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertTrue( n.getType() == libsbml.AST_PLUS ); assertTrue( n.getCharacter() == '+' ); i = n.setType(libsbml.AST_FUNCTION_ARCCOSH); assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS ); assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOSH ); i = n.setType(libsbml.AST_UNKNOWN); assertTrue( i == libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE ); assertTrue( n.getType() == libsbml.AST_UNKNOWN ); n = null; }
public void test_ValidASTNode_returnsBoolean() { ASTNode node = new ASTNode ( libsbml.AST_LOGICAL_AND ); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_LOGICAL_NOT); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_LOGICAL_OR); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_LOGICAL_XOR); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_FUNCTION_PIECEWISE); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_EQ); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_GEQ); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_GT); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_LEQ); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_LT); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_RELATIONAL_NEQ); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_CONSTANT_TRUE); assertEquals( true, node.returnsBoolean() ); node.setType(libsbml.AST_CONSTANT_FALSE); assertEquals( true, node.returnsBoolean() ); }
//=============================================================================== // // // Functions for creating the Example SBML documents. // // //=============================================================================== /** * * Creates an SBML model represented in "7.1 A Simple example application of SBML" * in the SBML Level 2 Version 4 Specification. * */ private static SBMLDocument createExampleEnzymaticReaction() { int level = Level; int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument sbmlDoc = new SBMLDocument(level, version); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model model = sbmlDoc.createModel(); model.setId("EnzymaticReaction"); //--------------------------------------------------------------------------- // // Creates UnitDefinition objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers (reused more than once below). UnitDefinition unitdef; Unit unit; //--------------------------------------------------------------------------- // (UnitDefinition1) Creates an UnitDefinition object ("per_second") //--------------------------------------------------------------------------- unitdef = model.createUnitDefinition(); unitdef.setId("per_second"); // Creates an Unit inside the UnitDefinition object unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_SECOND); unit.setExponent(-1); //-------------------------------------------------------------------------------- // (UnitDefinition2) Creates an UnitDefinition object ("litre_per_mole_per_second") //-------------------------------------------------------------------------------- // 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("litre_per_mole_per_second"); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_MOLE); unit.setExponent(-1); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_LITRE); unit.setExponent(1); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_SECOND); unit.setExponent(-1); //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment comp; string compName = "cytosol"; // Creates a Compartment object ("cytosol") comp = model.createCompartment(); comp.setId(compName); // Sets the "size" attribute of the Compartment object. // // We are not setting the units on the compartment size explicitly, so // the units of this Compartment object will be the default SBML units of // volume, which are liters. // comp.setSize(1e-14); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointer (reused more than once below). Species sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("ES") //--------------------------------------------------------------------------- // Create the Species objects inside the Model object. sp = model.createSpecies(); sp.setId("ES"); sp.setName("ES"); // Sets the "compartment" attribute of the Species object to identify the // compartment in which the Species object is located. sp.setCompartment(compName); // Sets the "initialAmount" attribute of the Species object. // // In SBML, the units of a Species object's initial quantity are // determined by two attributes, "substanceUnits" and // "hasOnlySubstanceUnits", and the "spatialDimensions" attribute // of the Compartment object ("cytosol") in which the species // object is located. Here, we are using the default values for // "substanceUnits" (which is "mole") and "hasOnlySubstanceUnits" // (which is "false"). The compartment in which the species is // located uses volume units of liters, so the units of these // species (when the species appear in numerical formulas in the // model) will be moles/liters. // sp.setInitialAmount(0); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("P") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setCompartment(compName); sp.setId("P"); sp.setName("P"); sp.setInitialAmount(0); //--------------------------------------------------------------------------- // (Species3) Creates a Species object ("S") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setCompartment(compName); sp.setId("S"); sp.setName("S"); sp.setInitialAmount(1e-20); //--------------------------------------------------------------------------- // (Species4) Creates a Species object ("E") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setCompartment(compName); sp.setId("E"); sp.setName("E"); sp.setInitialAmount(5e-21); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction reaction; SpeciesReference spr; KineticLaw kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("veq"). //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("veq"); // (Reactant1) Creates a Reactant object that references Species "E" // in the model. The object will be created within the reaction in the // SBML <listOfReactants>. spr = reaction.createReactant(); spr.setSpecies("E"); // (Reactant2) Creates a Reactant object that references Species "S" // in the model. spr = reaction.createReactant(); spr.setSpecies("S"); //--------------------------------------------------------------------------- // (Product1) Creates a Product object that references Species "ES" in // the model. //--------------------------------------------------------------------------- spr = reaction.createProduct(); spr.setSpecies("ES"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("veq"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); //--------------------------------------------------------------------------- // Creates an ASTNode object which represents the following math of the // KineticLaw. // // <math xmlns="http://www.w3.org/1998/Math/MathML"> // <apply> // <times/> // <ci> cytosol </ci> // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // </apply> // </math> // //--------------------------------------------------------------------------- //------------------------------------------ // // create nodes representing the variables // //------------------------------------------ ASTNode astCytosol = new ASTNode(libsbml.AST_NAME); astCytosol.setName("cytosol"); ASTNode astKon = new ASTNode(libsbml.AST_NAME); astKon.setName("kon"); ASTNode astKoff = new ASTNode(libsbml.AST_NAME); astKoff.setName("koff"); ASTNode astE = new ASTNode(libsbml.AST_NAME); astE.setName("E"); ASTNode astS = new ASTNode(libsbml.AST_NAME); astS.setName("S"); ASTNode astES = new ASTNode(libsbml.AST_NAME); astES.setName("ES"); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // //-------------------------------------------- ASTNode astTimes1 = new ASTNode(libsbml.AST_TIMES); astTimes1.addChild(astKoff); astTimes1.addChild(astES); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // // // (NOTES) // // Since there is a restriction with an ASTNode of "<times/>" operation // such that the ASTNode is a binary class and thus only two operands can // be directly added, the following code in this comment block is invalid // because the code directly adds three <ci> ASTNodes to <times/> ASTNode. // // ASTNode *astTimes = new ASTNode(libsbml.AST_TIMES); // astTimes.addChild(astKon); // astTimes.addChild(astE); // astTimes.addChild(astS); // // The following valid code after this comment block creates the ASTNode // as a binary tree. // // Please see "Converting between ASTs and text strings" described // at http://sbml.org/Software/libSBML/docs/cpp-api/class_a_s_t_node.html // for the detailed information. // //-------------------------------------------- ASTNode astTimes2 = new ASTNode(libsbml.AST_TIMES); astTimes2.addChild(astE); astTimes2.addChild(astS); ASTNode astTimes = new ASTNode(libsbml.AST_TIMES); astTimes.addChild(astKon); astTimes.addChild(astTimes2); //-------------------------------------------- // // create node representing // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // //-------------------------------------------- ASTNode astMinus = new ASTNode(libsbml.AST_MINUS); astMinus.addChild(astTimes); astMinus.addChild(astTimes1); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> cytosol </ci> // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // </apply> // //-------------------------------------------- ASTNode astMath = new ASTNode(libsbml.AST_TIMES); astMath.addChild(astCytosol); astMath.addChild(astMinus); //--------------------------------------------- // // set the Math element // //------------------------------------------------ kl.setMath(astMath); //--------------------------------------------------------------------------- // Creates local Parameter objects inside the KineticLaw object. //--------------------------------------------------------------------------- // Creates a Parameter ("kon") Parameter para = kl.createParameter(); para.setId("kon"); para.setValue(1000000); para.setUnits("litre_per_mole_per_second"); // Creates a Parameter ("koff") para = kl.createParameter(); para.setId("koff"); para.setValue(0.2); para.setUnits("per_second"); //--------------------------------------------------------------------------- // (Reaction2) Creates a Reaction object ("vcat") . //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("vcat"); reaction.setReversible(false); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "ES" in the // model. spr = reaction.createReactant(); spr.setSpecies("ES"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- // (Product1) Creates a Product object that references Species "E" in the model. spr = reaction.createProduct(); spr.setSpecies("E"); // (Product2) Creates a Product object that references Species "P" in the model. spr = reaction.createProduct(); spr.setSpecies("P"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); //--------------------------------------------------------------------------- // 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/>" + " <ci> cytosol </ci>" + " <ci> kcat </ci>" + " <ci> ES </ci>" + " </apply>" + "</math>"; astMath = libsbml.readMathMLFromString(mathXMLString); kl.setMath(astMath); //--------------------------------------------------------------------------- // Creates local Parameter objects inside the KineticLaw object. //--------------------------------------------------------------------------- // Creates a Parameter ("kcat") para = kl.createParameter(); para.setId("kcat"); para.setValue(0.1); para.setUnits("per_second"); // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise a memory leak will happen. return sbmlDoc; }
public void test_element_power() { string s = wrapMathML("<apply><power/> <ci>x</ci> <cn>3</cn> </apply>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "pow(x, 3)" == F )); }
public void test_element_piecewise_otherwise() { string s = wrapMathML("<piecewise>" + " <piece>" + " <cn>0</cn>" + " <apply> <lt/> <ci>x</ci> <cn>0</cn> </apply>" + " </piece>" + " <otherwise>" + " <ci>x</ci>" + " </otherwise>" + "</piecewise>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "piecewise(0, lt(x, 0), x)" == F )); }
public void test_element_piecewise() { string s = wrapMathML("<piecewise>" + " <piece>" + " <apply> <minus/> <ci>x</ci> </apply>" + " <apply> <lt/> <ci>x</ci> <cn>0</cn> </apply>" + " </piece>" + " <piece>" + " <cn>0</cn>" + " <apply> <eq/> <ci>x</ci> <cn>0</cn> </apply>" + " </piece>" + " <piece>" + " <ci>x</ci>" + " <apply> <gt/> <ci>x</ci> <cn>0</cn> </apply>" + " </piece>" + "</piecewise>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "piecewise(-x, lt(x, 0), 0, eq(x, 0), x, gt(x, 0))" == F )); }
public void test_element_operator_times() { string s = wrapMathML("<apply> <times/> <ci> x </ci> <ci> y </ci> <ci> z </ci> </apply>" ); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "x * y * z" == F )); }
public void test_element_operator_plus() { string s = wrapMathML("<apply> <plus/> <cn> 1 </cn> <cn> 2 </cn> <cn> 3 </cn> </apply>" ); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "1 + 2 + 3" == F )); }
public void test_element_not() { string s = wrapMathML("<apply> <not/> <ci> TooShabby </ci> </apply>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "not(TooShabby)" == F )); }
/** * If this object has a child 'math' object (or anything with ASTNodes in * general), replace all nodes with the name 'id' with the provided * function. * * @note This function does nothing itself—subclasses with ASTNode * subelements must override this function. */ /* libsbml-internal */ public void replaceSIDWithFunction(string id, ASTNode function) { libsbmlPINVOKE.SBase_replaceSIDWithFunction(swigCPtr, id, ASTNode.getCPtr(function)); if (libsbmlPINVOKE.SWIGPendingException.Pending) throw libsbmlPINVOKE.SWIGPendingException.Retrieve(); }
/** * If the function of this object is to assign a value has a child 'math' * object (or anything with ASTNodes in general), replace the 'math' * object with the function (existing/function). * * @note This function does nothing itself—subclasses with ASTNode * subelements must override this function. */ /* libsbml-internal */ public void divideAssignmentsToSIdByFunction(string id, ASTNode function) { libsbmlPINVOKE.SBase_divideAssignmentsToSIdByFunction(swigCPtr, id, ASTNode.getCPtr(function)); if (libsbmlPINVOKE.SWIGPendingException.Pending) throw libsbmlPINVOKE.SWIGPendingException.Retrieve(); }
public void test_element_tanh() { string s = wrapMathML("<apply><tanh/><ci> x </ci></apply>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "tanh(x)" == F )); }
public void test_ValidASTNode_root() { ASTNode n = new ASTNode(libsbml.AST_FUNCTION_ROOT); assertEquals( false, (n.isWellFormedASTNode()) ); ASTNode c = libsbml.parseFormula("c"); n.addChild(c); assertEquals( true, n.isWellFormedASTNode() ); ASTNode d = libsbml.parseFormula("3"); n.addChild(d); assertEquals( true, n.isWellFormedASTNode() ); ASTNode e = libsbml.parseFormula("3"); n.addChild(e); assertEquals( false, (n.isWellFormedASTNode()) ); n = null; }
public void test_element_xor() { string s = wrapMathML("<apply> <xor/> <ci>a</ci> <ci>b</ci> <ci>b</ci> <ci>a</ci> </apply>" ); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "xor(a, b, b, a)" == F )); }
public void test_element_root_1() { string s = wrapMathML("<apply> <root/> <degree> <cn type='integer'> 3 </cn> </degree>" + " <ci> a </ci>" + "</apply>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "root(3, a)" == F )); }
public void test_element_math() { string s = wrapXML("<math xmlns='http://www.w3.org/1998/Math/MathML'/>" ); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); assertTrue( N.getType() == libsbml.AST_UNKNOWN ); }
/** * * 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; }
public void test_element_root_2() { string s = wrapMathML("<apply> <root/> <ci> a </ci> </apply>"); N = libsbml.readMathMLFromString(s); assertTrue( N != null ); F = libsbml.formulaToString(N); assertTrue(( "sqrt(a)" == F )); }