Function class

(Shortest import: from brian2 import Function)

class brian2.core.functions.Function(pyfunc, sympy_func=None, arg_units=None, arg_names=None, return_unit=None, arg_types=None, return_type=None, stateless=True, auto_vectorise=False)

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.

arg_types : list of str, optional

Similar to arg_units, but gives the type of the argument rather than its unit. In the current version of Brian arguments are specified by one of the following strings: ‘boolean’, ‘integer’, ‘float’, ‘any’. If arg_types is not specified, ‘any’ will be assumed. In future versions, a more refined specification may be possible. Note that any argument with a type other than float should have no units. If

return_type : str, optional

Similar to return_unit and arg_types. In addition to ‘boolean’, ‘integer’ and ‘float’ you can also use ‘highest’ which will return the highest type of its arguments. You can also give a function, as for return_unit. If the return type is not specified, it is assumed to be ‘float’.

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.

auto_vectorise : bool, optional

Whether the implementations of this function should get an additional argument (not specified in abstract code) that can be used to determine the number of values that should be returned (for the numpy target), or an index potentially useful for generating deterministic values independent of the order of vectorisation (for all other targets). The main use case are random number functions, e.g. equations refer to rand(), but the generate code will actually call rand(_vectorisation_idx). Defaults to False.

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 FunctionImplementationContainer

Methods

__call__(*args)	Call self as a function.
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)

Call self as a function.

is_locally_constant(dt)

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.