Inheritance diagram for CellMLToNektar.optimize.LookupTableAnalyser.LUTState:

[legend]

Public Member Functions
def	__init__ (self)

def	update (self, res)

def	suitable (self)

def	reason (self)

Public Attributes
	has_var

	bad_vars

	has_func

	table_var

Detailed Description

Represents the state for lookup table analysis.

Definition at line 479 of file optimize.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.optimize.LookupTableAnalyser.LUTState.__init__ ( self )

Set the initial state.

We assume at first a lookup table would not be suitable.

Definition at line 481 of file optimize.py.

        def __init__(self):
            """Set the initial state.
 
            We assume at first a lookup table would not be suitable.
            """
            self.has_var = False
            self.bad_vars = set()
            self.has_func = False
            self.table_var = None
 

Member Function Documentation

◆ reason()

def CellMLToNektar.optimize.LookupTableAnalyser.LUTState.reason ( self )

Return a unicode string describing why this state indicates the
expression is not suitable for replacement with a lookup table.

This can be:
 'no_var' - doesn't contain the table variable
 'bad_var <vname>' - contains a variable which isn't permitted
 'no_func' - doesn't contain an expensive function
or a comma separated combination of the above.

Definition at line 517 of file optimize.py.

        def reason(self):
            """
            Return a unicode string describing why this state indicates the
            expression is not suitable for replacement with a lookup table.
 
            This can be:
             'no_var' - doesn't contain the table variable
             'bad_var <vname>' - contains a variable which isn't permitted
             'no_func' - doesn't contain an expensive function
            or a comma separated combination of the above.
            """
            r = []
            if not self.has_var:
                r.append(u'no_var')
            if not self.has_func:
                r.append(u'no_func')
            for vname in self.bad_vars:
                r.append(u'bad_var ' + vname)
            return u','.join(r)
 
    def create_state_from_annotations(self, expr):

References CellMLToNektar.optimize.LookupTableAnalyser.LUTState.bad_vars, CellMLToNektar.optimize.LookupTableAnalyser.LUTState.has_func, and CellMLToNektar.optimize.LookupTableAnalyser.LUTState.has_var.

◆ suitable()

def CellMLToNektar.optimize.LookupTableAnalyser.LUTState.suitable ( self )

Return True iff this state indicates a suitable expression for replacement with a lookup table.

Definition at line 511 of file optimize.py.

        def suitable(self):
            """Return True iff this state indicates a suitable expression for replacement with a lookup table."""
            return (self.has_var and
                    not self.bad_vars and
                    self.has_func)
 

References CellMLToNektar.optimize.LookupTableAnalyser.LUTState.bad_vars, CellMLToNektar.optimize.LookupTableAnalyser.LUTState.has_func, and CellMLToNektar.optimize.LookupTableAnalyser.LUTState.has_var.

◆ update()

def CellMLToNektar.optimize.LookupTableAnalyser.LUTState.update	(	self,
		res
	)

Update the state with the results of a recursive call.

res is the result of checking a sub-expression for suitability,
and should be another instance of this class.

Definition at line 491 of file optimize.py.

        def update(self, res):
            """Update the state with the results of a recursive call.
 
            res is the result of checking a sub-expression for suitability,
            and should be another instance of this class.
            """
            self.has_var = (self.has_var or res.has_var) and \
                           (not (self.table_var and res.table_var) or
                            self.table_var.get_source_variable(recurse=True) is
                             res.table_var.get_source_variable(recurse=True))
            # The second condition above specifies that the keying variables must be the same if they both exist
            self.bad_vars.update(res.bad_vars)
            self.has_func = self.has_func or res.has_func
            self.table_var = self.table_var or res.table_var
            if not self.has_var and self.table_var:
                # Two sub-expressions have different keying variables, so consider them as bad variables
                self.bad_vars.add(self.table_var.name)
                self.bad_vars.add(res.table_var.name)
                self.table_var = None
 