Function class

(Shortest import: from brian2 import Function)

class brian2.core.functions.Function(pyfunc, sympy_func=None, arg_units=None, return_unit=None, stateless=True)[source]

Bases: object

An abstract specification of a function that can be used as part of model equations, etc.

Parameters:

pyfunc : function

A Python function that is represented by this Function object.

sympy_func : sympy.Function, optional

A corresponding sympy function (if any). Allows functions to be interpreted by sympy and potentially make simplifications. For example, sqrt(x**2) could be replaced by abs(x).

arg_units : list of Unit, optional

If pyfunc does not provide unit information (which typically means that it was not annotated with a check_units() decorator), the units of the arguments have to specified explicitly using this parameter.

return_unit : Unit or callable, optional

Same as for arg_units: if pyfunc does not provide unit information, this information has to be provided explictly here. return_unit can either be a specific Unit, if the function always returns the same unit, or a function of the input units, e.g. a “square” function would return the square of its input units, i.e. return_unit could be specified as lambda u: u**2.

stateless : bool, optional

Whether this function does not have an internal state, i.e. if it always returns the same output when called with the same arguments. This is true for mathematical functions but not true for rand(), for example. Defaults to True.

Notes

If a function should be usable for code generation targets other than Python/numpy, implementations for these target languages have to be added using the implementation decorator or using the add_implementations function.

Attributes

implementations Stores implementations for this function in a

Methods

__call__(*args)
is_locally_constant(dt) Return whether this function (if interpreted as a function of time) should be considered constant over a timestep.

Details

implementations

Stores implementations for this function in a FunctionImplementationContainer

__call__(*args)[source]
is_locally_constant(dt)[source]

Return whether this function (if interpreted as a function of time) should be considered constant over a timestep. This is most importantly used by TimedArray so that linear integration can be used. In its standard implementation, always returns False.

Parameters:

dt : float

The length of a timestep (without units).

Returns:

constant : bool

Whether the results of this function can be considered constant over one timestep of length dt.