CellMLToNektar.pycml.mathml_power Class Reference

Inheritance diagram for CellMLToNektar.pycml.mathml_power:

Public Member Functions
def	evaluate (self)
Public Member Functions inherited from CellMLToNektar.pycml.mathml_operator
def	wrong_number_of_operands (self, found, wanted)
Public Member Functions inherited from CellMLToNektar.pycml.mathml
def	__init__ (self)
def	__repr__ (self)
def	__deepcopy__ (self, memo)
def	clone_self (self, register=False)
def	get_original_of_clone (self)
def	get_component (self)
def	model (self)
def	eval (self, elt)
Public Member Functions inherited from CellMLToNektar.pycml.element_base
def	__delattr__ (self, key)
def	__setattr__ (self, key, value)
def	rootNode (self)
def	cmeta_id (self)
def	xml_remove_child_at (self, index=-1)
def	xml_doc (self)
def	xml_properties (self)

Private Member Functions
def	_set_in_units (self, units, no_act=False)
def	_reduce (self)

Additional Inherited Members
Static Public Member Functions inherited from CellMLToNektar.pycml.mathml
def	clone (expr)
Public Attributes inherited from CellMLToNektar.pycml.element_base
	xml_attributes
Properties inherited from CellMLToNektar.pycml.mathml
	component = property(get_component)

Detailed Description

Class representing the MathML <power> operator.

Definition at line 5692 of file pycml.py.

Member Function Documentation

_reduce()

def CellMLToNektar.pycml.mathml_power._reduce (   self )

private

Reduce this expression by evaluating its static parts.

If the whole expression is static, proceed as normal for an <apply>.
Otherwise check if the exponent is static and the expression being exponentiated
is a <ci>.  If so, and the exponent is equal to 2, 3, or 4, convert the expression
to a multiplication.

Definition at line 5728 of file pycml.py.

    def _reduce(self):
        """Reduce this expression by evaluating its static parts.
 
        If the whole expression is static, proceed as normal for an <apply>.
        Otherwise check if the exponent is static and the expression being exponentiated
        is a <ci>.  If so, and the exponent is equal to 2, 3, or 4, convert the expression
        to a multiplication.
        """
        app = self.xml_parent
        bt = app._get_binding_time()
        converted = False
        if bt != BINDING_TIMES.static and self.model.get_option('pe_convert_power'):
            base, expt = list(app.operands())
            expt_bt = app._get_element_binding_time(expt)
            if expt_bt == BINDING_TIMES.static and isinstance(base, mathml_ci):
                expt_val = self.eval(expt)
                if expt_val in [2,3,4]:
                    # Do the conversion
                    app.safe_remove_child(base)
                    operands = [base]
                    for _ in range(1, expt_val):
                        operands.append(base.clone_self())
                        base.variable._used()
                    new_app = mathml_apply.create_new(app, u'times', operands)
                    app.replace_child(app, new_app, app.xml_parent)
                    # Finally, reduce the new expression, just to be safe!
                    new_app._reduce()
                    converted = True
        if not converted:
            # Evaluate this expression as normal
            app._reduce(check_operator=False)
 

References CellMLToNektar.pycml.mathml.eval(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

_set_in_units()

def CellMLToNektar.pycml.mathml_power._set_in_units (   self,   units,   no_act = False  )

private

Set the units of the application of this operator.

Set the exponent to have units of dimensionless, and the operand to
have an arbitrary member of its possible units set.

Where these mean the <apply> doesn't have the given units, wrap it
in suitable units conversion mathematics.

Definition at line 5694 of file pycml.py.

    def _set_in_units(self, units, no_act=False):
        """Set the units of the application of this operator.
 
        Set the exponent to have units of dimensionless, and the operand to
        have an arbitrary member of its possible units set.
 
        Where these mean the <apply> doesn't have the given units, wrap it
        in suitable units conversion mathematics.
        """
        app = self.xml_parent
        defn_units_set = app.get_units()
        defn_units = defn_units_set.extract()
        app._add_units_conversion(app, defn_units, units, no_act)
        # Record which member of the set we used
        if not no_act:
            app._cml_units = defn_units
        # Set exponent units
        dimensionless = app.model.get_units_by_name('dimensionless')
        ops = list(app.operands())
        self._set_element_in_units(ops[1], dimensionless, no_act)
        # Set operand units
        for src_units_set, src_units in defn_units_set._get_sources(defn_units):
            expr = src_units_set.get_expression()
            self._set_element_in_units(expr, src_units, no_act)
        return
 

References CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units().

evaluate()

def CellMLToNektar.pycml.mathml_power.evaluate

(

self

)

Return the first operand to the power of the second.

Definition at line 5720 of file pycml.py.

    def evaluate(self):
        """Return the first operand to the power of the second."""
        app = self.xml_parent
        ops = list(app.operands())
        if len(ops) != 2:
            self.wrong_number_of_operands(len(ops), [2])
        return self.eval(ops[0]) ** self.eval(ops[1])
 

References CellMLToNektar.pycml.mathml.eval(), and CellMLToNektar.pycml.mathml_operator.wrong_number_of_operands().

Referenced by CellMLToNektar.pycml.mathml_constructor._eval_self(), and CellMLToNektar.pycml.mathml_ci._reduce().