Expression

class flopt.expression.Expression(elmA, elmB, operator, name=None)

Expression Base Class

This represents the operation of two items elmA (operator) elmB

Parameters:

• elmA (Variable family or Expression family) – first element

• elmB (Variable family or Expression family) – later element

• operator (str) – operator between elmA and elmB

elmA

first element

Type:

Variable family or Expression family

elmB

later element

Type:

Variable family or Expression family

operator

operator between elmA and elmB

Type:

str

Examples

import flopt
from flopt.expression import Expression

a = flopt.Variable(name="a", ini_value=1, cat="Integer")
b = flopt.Variable(name="b", ini_value=2, cat="Continuous")
c = Expression(a, b, "+")  # same as a + b
c
>>> a+b
c.value()
>>> 3
c.getVariables()
>>> {VarElement("b", 1, 2, 2), VarElement("a", 0, 1, 1)}

operator “+”, “-”, “*”, “/”, “^” and “%” are supported for Integer, Binary and Continuous Variables.

import flopt
from flopt.expression import Expression

a = flopt.Variable(name="a", ini_value=1, cat="Integer")  # a.value() is 1
b = flopt.Variable(name="b", ini_value=2, cat="Continuous")  # b.value() is 2
Expression(a, b, "+").value()  # a+b addition
>>> 3
Expression(a, b, "-").value()  # a-b substraction
>>> -1
Expression(a, b, "*").value()  # a*b multiplication
>>> 2
Expression(a, b, "/").value()  # a/b division
>>> 0.5
Expression(a, b, "^").value()  # a/b division
>>> 1
Expression(a, b, "%").value()  # a%b modulo
>>> 1

operator “&”, “|” are supported for Binary Variable.

import flopt
from flopt.expression import Expression

a = flopt.Variable(name="a", ini_value=1, cat="Binary")
b = flopt.Variable(name="b", ini_value=0, cat="Binary")
Expression(a, b, "&").value().value()  # a&b bitwise and
>>> 0
Expression(a, b, "|").value().value()  # a&b bitwise or
>>> 1

clone()

Return type:

Expression

diff(x)

Parameters:

x (VarElement family) –

Returns:

the expression differentiated by x

Return type:

Expression

expand()

Return type:

Expression

getVariables()

Returns:

return the variable object used in this expressiono

Return type:

set

hess(x)

hessian :param x: :type x: list or numpy.array of VarElement family

Returns:

hess – hess[i, j] = hessian of self for x[i] and x[j]

Return type:

numpy array of Expression

Examples

import flopt

x = flopt.Variable("x")
y = flopt.Variable("y")

f = x * x * y

# hessian matrix for [x, y]
print(f.hess([x, y]))
>>> [[Expression(y, 0, +) Expression(x, 0, +)]
>>>  [Expression(2*x, 0, +) Const(0)]]

# hessian matrix for [x, y]
print(f.hess([y, x]))
>>> [[Const(0) Expression(2*x, 0, +)]
>>>  [Expression(x, 0, +) Expression(y, 0, +)]]

isIsing()

Returns:

return true if this expression is ising else false

Return type:

bool

isLinear()

Returns:

return true if this expression is linear else false

Return type:

bool

Examples

>>> from flopt import Variable
>>> a = Variable('a', ini_value=3)
>>> b = Variable('b', ini_value=3)
>>> (a+b).isLinear()
>>> True
>>> (a*b).isLinear()
>>> False

isNeg()

Returns:

return if it is - value form else false

Return type:

bool

isQuadratic()

Returns:

return true if this expression is quadratic else false

Return type:

bool

jac(x)

jacobian :param x: :type x: list or numpy.array of VarElement family

Returns:

jac – jac[i] = jacobian of self for x[i]

Return type:

numpy array of Expression

Examples

import flopt

x = flopt.Variable("x")
y = flopt.Variable("y")

f = x * y

# jacobian vector for [x, y]
f.jac([x, y])
>>> [Expression(y, 0, +) Expression(x, 0, +)]

# jacobian vector for [y, x]
f.jac([y, x])
>>> [Expression(x, 0, +) Expression(y, 0, +)]

max(*args, **kwargs)

Calculate max value of expression when expression is linear or quadratic

Returns:

maximum value of this expression can take

Return type:

float

maximize(solver='auto', *args, **kwargs)

Optimize the maximize problem has this expression as objective

min(*args, **kwargs)

Calculate min value of expression when expression is linear or quadratic

Returns:

minimum value of this expression can take

Return type:

float

minimize(solver='auto', *args, **kwargs)

Optimize the minimize problem has this expression as objective

simplify()

Return type:

Expression

toBinary()

create expression replased binary to spin

Return type:

Expression

toIsing(x=None)

Parameters:

x (list or numpy.array or VarElement family) –

Returns:

IsingStructure(‘IsingStructure’, ‘J h x’), converted from sum(a_ij x_i x_j; i >= j) + sum(b_i x_i) + c = sum(a_ij x_i x_j; i >= j) + sum(b_i x_i) + sum(c/n x_i x_i), as J_ij = a_ij (i != j), a_ii + c/n (i == j), h_i = b_i

Return type:

collections.namedtuple

toLinear(x=None)

Parameters:

x (list or numpy.array of VarElement family) –

Returns:

LinearStructure = collections.namedtuple(‘LinearStructure’, ‘c C x’), where c.T.dot(x) + C

Return type:

collections.namedtuple

toQuadratic(x=None)

Parameters:

x (list or numpy.array or VarElement family) –

Returns:

QuadraticStructure(‘QuadraticStructure’, ‘Q c C x’), such that 1/2 x^T Q x + c^T x + C, Q^T = Q

Return type:

collections.namedtuple

toSpin()

create expression replased binary to spin

Return type:

Expression

traverse()

traverse Expression tree as root is self

Yields:

Expression or VarElement

traverseAncestors()

traverse ancestors of self

Yields:

Expression or VarElement

value(solution=None, var_dict=None)

Returns:

return value of expression

Return type:

float or int