Functions and Relations

class sigmaepsilon.math.function.Function(f0: FuncionLike | None = None, f1: Callable | None = None, f2: Callable | None = None, *args, variables=None, **kwargs)

Base class for all kinds of functions.

Parameters:

• f0 (Callable) – A callable object that returns function evaluations.

• f1 (Callable) – A callable object that returns evaluations of the gradient of the function.

• f2 (Callable) – A callable object that returns evaluations of the Hessian of the function.

• variables (List, Optional) – Symbolic variables. Only required if the function is defined by a string or SymPy expression.

• value (Callable, Optional) – Same as f0.

• gradient (Callable, Optional) – Same as f1.

• Hessian (Callable, Optional) – Same as f2.

• d (dimension or dim or) – The number of dimensions of the domain of the function. Required only when going full blind, in most of the cases it can be inferred from other properties.

Examples

>>> from sigmaepsilon.math.function import Function
>>> import sympy as sy

Define a symbolic function with positive variables. Note here that if it was not relevant from the aspect of the application to indicate that the variables are positive, it wouldn’t be necessary to explicity specify them using the parameter variables.

>>> variables = ['x1', 'x2', 'x3', 'x4']
>>> x1, x2, x3, x4 = syms = sy.symbols(variables, positive=True)
>>> f = Function(3*x1 + 9*x3 + x2 + x4, variables=syms)
>>> f([0, 6, 0, 4])
10

Define a numerical function. In this case the dimension of the input must be specified explicitly.

>>> def f0(x, y): return x**2 + y
>>> def f1(x, y): return np.array([2*x, 1])
>>> def f2(x, y): return np.array([[0, 0], [0, 0]])
>>> f = Function(f0, f1, f2, d=2)
>>> f.linear
False

To call the function, call it like you would call the function f0:

>>> f(1, 1)
2
>>> f.g(1, 1)
array([2, 1])

You can mix different kinds of input signatures:

>>> def f0(x): return x[0]**2 + x[1]
>>> def f1(x, y): return np.array([2*x, 1])
>>> def f2(x, y): return np.array([[0, 0], [0, 0]])
>>> f = Function(f0, f1, f2, d=2)

The point is that you always call the resulting Function object according to your definition. Now your f0 expects an iterable, therefore you can call it like

>>> f([1, 1])
2

but the gradient function expects the same values as two scalars, so you call it like this

>>> f.g(1, 1)
array([2, 1])

Explicity defining the variables for a symbolic function is important if not all variables appear in the string expression you feed the object with:

>>> g = Function('3*x + 4*y - 2', variables=['x', 'y', 'z'])
>>> g.linear
True

If you do not specify ‘z’ as a variable here, the resulting object expects two values

>>> h = Function('3*x + 4*y - 2')
>>> h([1, 1])
5

The variables can be SymPy variables as well:

>>> m = Function('3*x + 4*y - 2', variables=sy.symbols('x y z'))
>>> m.linear
True
>>> m([1, 2, -30])
9

coefficients(normalize: bool = False)

Returns the coefficients if the function is symbolic.

property linear

Returns True if the function is at most linear in all of its variables.

linear_coefficients(normalize: bool = False)

Returns the linear coeffiecients, if the function is symbolic.

subs(values, variables=None, inplace=False)

Substitites values for variables.

property symbolic

Returns True if the function is a fit subject of symbolic manipulation. This is probably only true if the object was created from a string or sympy expression.

to_latex()

Returns the LaTeX code of the symbolic expression of the object. Only for simbolic functions.

class sigmaepsilon.math.function.Equality(*args, **kwargs)

Class for equality constraints.

Example

>>> import sympy as sy
>>> variables = ['x1', 'x2', 'x3', 'x4']
>>> x1, x2, x3, x4 = syms = sy.symbols(variables, positive=True)
>>> eq1 = Equality(x1 + 2*x3 + x4 - 4, variables=syms)
>>> eq2 = Equality(x2 + x3 - x4 - 2, variables=syms)

class sigmaepsilon.math.function.InEquality(*args, **kwargs)

Class for inequality constraints.

Examples

>>> gt = InEquality('x + y', op='>')
>>> gt([0.0, 0.0])
0.0

>>> ge = InEquality('x + y', op='>=')
>>> ge([0.0, 0.0])
0.0

>>> le = InEquality('x + y', op=lambda x, y: x <= y)
>>> le([0.0, 0.0])
0.0

>>> lt = InEquality('x + y', op=lambda x, y: x < y)
>>> lt([0.0, 0.0])
0.0

Test Functions

sigmaepsilon.math.function.functions.Beale()

Creates the Beale function object.

\begin{equation} f(x, y) = (1.5 - x + x y)^2 + (2.25 - x + x y^2)^2 + (2.625 - x + x y^3)^2 \end{equation}

One global minimum : f(3,0.5) = 0.

sigmaepsilon.math.function.functions.GoldsteinPrice()

Creates the Goldstein-Price function object.

\begin{equation} f(x, y) = (1 + (x + y + 1)^2 (19-14x + 3x^2 - 14y + 6xy + 3y^2)) (30 + (2x - 3y)^2 (18 - 32x + 12x^2 + 48y - 36xy + 27y^2)) \end{equation}

One global minimum : f(0,-1) = 3.

sigmaepsilon.math.function.functions.Himmelblau()

Creates the Himmelblau’s function object.

\(f(x,y) = (x^2 + y - 11)^2 + (x + y^2 - 7)^2\)

Four identical local minima with values 0.0 at (3.0,2.0), (-2.805,3.131), (-3.779,-3.283), (3.584,-1.848).

sigmaepsilon.math.function.functions.Matyas()

Creates the Matyas function object.

\(f(x, y) = 0.26 (x^2 + y^2) - 0.48 x y\)

One global minimum : f(0., 0.) = 0.

sigmaepsilon.math.function.functions.Rosenbrock(a=1, b=100)

Implements the Rosenbrock function, aka. Banana function.

\(f(x, y) = (a - x)^2 + b (y - x^2)^2\)

a,b are constants, tipically a is set to 1 and b is set to 100.

One global minimum : f(1, 1) = 0.