from brian2 import Function)
Function(pyfunc, sympy_func=None, arg_units=None, return_unit=None, arg_types=None, return_type=None, stateless=True)¶
An abstract specification of a function that can be used as part of model equations, etc.
pyfunc : function
A Python function that is represented by this
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
arg_units : list of
pyfuncdoes 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.
Unitor callable, optional
Same as for
pyfuncdoes not provide unit information, this information has to be provided explictly here.
return_unitcan 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_unitcould be specified as
lambda u: u**2.
arg_types : list of str, optional
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_typesis 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
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
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
implementationdecorator or using the
Stores implementations for this function in a
__call__(…) <==> x(…)
Return whether this function (if interpreted as a function of time) should be considered constant over a timestep.
__call__(...) <==> x(...)¶
Return whether this function (if interpreted as a function of time) should be considered constant over a timestep. This is most importantly used by
TimedArrayso that linear integration can be used. In its standard implementation, always returns
dt : float
The length of a timestep (without units).
constant : bool
Whether the results of this function can be considered constant over one timestep of length