CellMLToNektar.pycml.mathml_constructor Class Reference

Inheritance diagram for CellMLToNektar.pycml.mathml_constructor:

Public Member Functions
def	__init__ (self)
Public Member Functions inherited from CellMLToNektar.pycml.mathml
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	_tree_complexity (self, elt, **kw)
def	_get_element_binding_time (self, elt)
def	_get_element_units (self, elt, return_set=True)
def	_reduce_elt (self, elt)
def	_eval_self (self)
def	_update_usage_counts (self, expr, remove=False)

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

Base class for MathML constructor elements, e.g. apply and piecewise.

Definition at line 4000 of file pycml.py.

Constructor & Destructor Documentation

__init__()

def CellMLToNektar.pycml.mathml_constructor.__init__

(

self

)

Reimplemented from CellMLToNektar.pycml.mathml.

Reimplemented in CellMLToNektar.pycml.mathml_piecewise, and CellMLToNektar.pycml.mathml_apply.

Definition at line 4004 of file pycml.py.

    def __init__(self):
        super(mathml_constructor, self).__init__()
        return
 

Member Function Documentation

_eval_self()

def CellMLToNektar.pycml.mathml_constructor._eval_self (   self )

private

Evaluate self and return <cn>, <true> or <false>, as appropriate.

Definition at line 4108 of file pycml.py.

    def _eval_self(self):
        """Evaluate self and return <cn>, <true> or <false>, as appropriate."""
        value = self.evaluate()
        if value is True:
            new_elt = self.xml_create_element(u'true', NSS[u'm'])
        elif value is False:
            new_elt = self.xml_create_element(u'false', NSS[u'm'])
        else:
            # Add a new <units> element to the document if needed
            attrs = self._ensure_units_exist()
            new_elt = self.xml_create_element(u'cn', NSS[u'm'],
                                              content=unicode("%.17g" % value),
                                              attributes=attrs)
        return new_elt
 

References CellMLToNektar.pycml.mathml._ensure_units_exist(), CellMLToNektar.pycml.mathml_cn.evaluate(), CellMLToNektar.pycml.mathml_ci.evaluate(), CellMLToNektar.pycml.mathml_apply.evaluate(), CellMLToNektar.pycml.mathml_piecewise.evaluate(), CellMLToNektar.pycml.mathml_plus.evaluate(), CellMLToNektar.pycml.mathml_minus.evaluate(), CellMLToNektar.pycml.mathml_times.evaluate(), CellMLToNektar.pycml.mathml_divide.evaluate(), CellMLToNektar.pycml.mathml_exp.evaluate(), CellMLToNektar.pycml.mathml_ln.evaluate(), CellMLToNektar.pycml.mathml_log.evaluate(), CellMLToNektar.pycml.mathml_abs.evaluate(), CellMLToNektar.pycml.mathml_power.evaluate(), CellMLToNektar.pycml.mathml_root.evaluate(), CellMLToNektar.pycml.mathml_and.evaluate(), CellMLToNektar.pycml.mathml_or.evaluate(), CellMLToNektar.pycml.mathml_leq.evaluate(), CellMLToNektar.pycml.mathml_lt.evaluate(), CellMLToNektar.pycml.mathml_geq.evaluate(), CellMLToNektar.pycml.mathml_gt.evaluate(), CellMLToNektar.pycml.mathml_neq.evaluate(), CellMLToNektar.pycml.mathml_eq.evaluate(), CellMLToNektar.pycml.mathml_rem.evaluate(), CellMLToNektar.pycml.mathml_logbase.evaluate(), CellMLToNektar.pycml.mathml_degree.evaluate(), CellMLToNektar.pycml.mathml_sin.evaluate(), CellMLToNektar.pycml.mathml_cos.evaluate(), CellMLToNektar.pycml.mathml_tan.evaluate(), CellMLToNektar.pycml.mathml_arcsin.evaluate(), CellMLToNektar.pycml.mathml_arccos.evaluate(), and CellMLToNektar.pycml.mathml_arctan.evaluate().

Referenced by CellMLToNektar.pycml.mathml_apply._reduce(), and CellMLToNektar.pycml.mathml_piecewise._reduce().

_get_element_binding_time()

def CellMLToNektar.pycml.mathml_constructor._get_element_binding_time (   self,   elt  )

private

Helper method to get the binding time of a MathML element.

Definition at line 4057 of file pycml.py.

    def _get_element_binding_time(self, elt):
        """Helper method to get the binding time of a MathML element."""
        if hasattr(elt, '_get_binding_time'):
            # Call the element's method
            return elt._get_binding_time()
        elif elt.localName in [u'true', u'false', u'exponentiale', u'pi']:
            return BINDING_TIMES.static
        else:
            raise EvaluationError("Don't know how to compute binding time"
                                  " of element " + elt.localName)
 

Referenced by CellMLToNektar.pycml.mathml_piecewise._get_binding_time(), CellMLToNektar.pycml.mathml_apply._get_binding_time(), CellMLToNektar.pycml.mathml_piecewise._reduce(), and CellMLToNektar.pycml.mathml_apply.get_units().

_get_element_units()

def CellMLToNektar.pycml.mathml_constructor._get_element_units (   self,   elt,   return_set = True  )

private

Helper method to get the units of a MathML element.

Definition at line 4068 of file pycml.py.

    def _get_element_units(self, elt, return_set=True):
        """Helper method to get the units of a MathML element."""
        if hasattr(elt, 'get_units'):
            # Element has a method to get its units, so call it
            u = elt.get_units()
        elif hasattr(elt, '_cml_units') and elt._cml_units:
            # Units have been cached
            u = elt._cml_units
        else:
            # Let's figure it out ourselves...
            if elt.localName in [u'false', u'true']:
                u = UnitsSet(
                    [self.component.get_units_by_name('cellml:boolean')],
                    expression=elt)
            elif elt.localName in [u'notanumber', u'pi', u'infinity',
                                   u'exponentiale']:
                u = UnitsSet(
                    [self.component.get_units_by_name('dimensionless')],
                    expression=elt)
            else:
                # Unknown or unexpected element
                raise UnitsError(self, u''.join([
                    u'Unsupported element "', elt.localName, '".']))
        if not return_set:
            u = u.extract()
        return u
 

References CellMLToNektar.pycml.cellml_variable.component, CellMLToNektar.pycml.mathml.component, and CellMLToNektar.pycml.get_units_by_name().

Referenced by CellMLToNektar.pycml.mathml_apply._get_operand_units(), CellMLToNektar.pycml.mathml_apply.get_units(), and CellMLToNektar.pycml.mathml_piecewise.get_units().

_reduce_elt()

def CellMLToNektar.pycml.mathml_constructor._reduce_elt (   self,   elt  )

private

Try to reduce the given element.

Call the _reduce method on elt, if it has one.
If not, do nothing (we assume elt cannot be reduced).

Definition at line 4095 of file pycml.py.

    def _reduce_elt(self, elt):
        """Try to reduce the given element.
 
        Call the _reduce method on elt, if it has one.
        If not, do nothing (we assume elt cannot be reduced).
        """
        if hasattr(elt, '_reduce') and callable(elt._reduce):
            elt._reduce()
        else:
            DEBUG('partial-evaluator', "Don't know how to reduce",
                  elt.localName)
        return
 

References CellMLToNektar.utilities.DEBUG().

Referenced by CellMLToNektar.pycml.mathml_apply._reduce(), and CellMLToNektar.pycml.mathml_piecewise._reduce().

_tree_complexity()

def CellMLToNektar.pycml.mathml_constructor._tree_complexity (   self,   elt, **  kw  )

private

Calculate a rough estimate of the computation time for
evaluating the given element.

If lookup_tables is True, then assume we're using lookup tables
where possible.
If store_result is True, the complexity is saved to the
_cml_complexity attribute.
If algebraic is True, the complexity is calculated as a dictionary,
mapping node types to the number of occurences of that type.

Definition at line 4008 of file pycml.py.

    def _tree_complexity(self, elt, **kw):
        """
        Calculate a rough estimate of the computation time for
        evaluating the given element.
        
        If lookup_tables is True, then assume we're using lookup tables
        where possible.
        If store_result is True, the complexity is saved to the
        _cml_complexity attribute.
        If algebraic is True, the complexity is calculated as a dictionary,
        mapping node types to the number of occurences of that type.
        """
        kw['lookup_tables'] = kw.get('lookup_tables', False)
        kw['store_result'] = kw.get('store_result', False)
        kw['algebraic'] = kw.get('algebraic', False)
        if kw['algebraic']:
            ac = {}
        if kw['lookup_tables'] and \
             elt.getAttributeNS(NSS['lut'], u'possible', u'no') == u'yes':
            # This elt will be replaced by a lookup table
            if hasattr(self.rootNode, 'num_lookup_tables'):
                # Count the number of used lookup tables
                self.rootNode.num_lookup_tables += 1
            # Cost per table: 2 lookups, 2 +, -, *, 3 ci
            if kw['algebraic']:
                ac['lookup'] = 2
                ac['op'] = 3
                ac['times'] = 1
                ac['variable'] = 3
            else:
                ac = 2*1 + 2*1 + 1 + 1 + 3*0.7
        elif hasattr(elt, 'tree_complexity') \
           and callable(elt.tree_complexity):
            ac = elt.tree_complexity(**kw)
        elif elt.localName in ['true', 'false', 'cn', 'exponentiale', 'pi']:
            if kw['algebraic']: ac['constant'] = 1
            else: ac = 0.5
        elif elt.localName == 'ci':
            if kw['algebraic']: ac['variable'] = 1
            else: ac = 0.7
        elif elt.localName in ['degree', 'logbase']:
            ac = self._tree_complexity(child_i(elt, 1), **kw)
        else:
            raise EvaluationError("Don't know complexity of element " +
                                  elt.localName)
        if kw['store_result'] and isinstance(elt, mathml):
            elt._cml_complexity = ac
        return ac
 

References CellMLToNektar.pycml.mathml_constructor._tree_complexity(), CellMLToNektar.pycml.child_i(), and CellMLToNektar.pycml.element_base.rootNode().

Referenced by CellMLToNektar.pycml.mathml_constructor._tree_complexity(), CellMLToNektar.pycml.mathml_apply.tree_complexity(), and CellMLToNektar.pycml.mathml_piecewise.tree_complexity().

_update_usage_counts()

def CellMLToNektar.pycml.mathml_constructor._update_usage_counts (   self,   expr,   remove = False  )

private

Update usage counts of variables used in the given expression.

By default, increment the usage count of any variable occuring
in a <ci> element within expr.  If remove is set to True,
then decrement the usage counts instead.

Definition at line 4123 of file pycml.py.

    def _update_usage_counts(self, expr, remove=False):
        """Update usage counts of variables used in the given expression.
 
        By default, increment the usage count of any variable occuring
        in a <ci> element within expr.  If remove is set to True,
        then decrement the usage counts instead.
        """
        if isinstance(expr, mathml_ci):
            if remove:
                expr.variable._decrement_usage_count()
            else:
                raise NotImplementedError("_update_usage_counts currently only reliable for remove=True")
                expr.variable._used()
        elif isinstance(expr, mathml_apply) and isinstance(expr.operator(),
                                                           mathml_diff):
            # TODO: Check if this is a suitable handling of ODEs on a RHS
            # It matches the current behaviour in apply.classify_variables.
            pass
        else:
            for e in self.xml_element_children(expr):
                self._update_usage_counts(e, remove=remove)
 

References CellMLToNektar.pycml.mathml_constructor._update_usage_counts().

Referenced by CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_piecewise._reduce(), and CellMLToNektar.pycml.mathml_constructor._update_usage_counts().