cvxpy.atoms.elementwise package

All of the atoms listed here operate elementwise on expressions. For example, exp exponentiates each entry of expressions that are supplied to it.

abs

class cvxpy.atoms.elementwise.abs.abs(x)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise absolute value

entr

class cvxpy.atoms.elementwise.entr.entr(x)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise \(-x\log x\).

exp

class cvxpy.atoms.elementwise.exp.exp(x)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise \(e^{x}\).

huber

class cvxpy.atoms.elementwise.huber.huber(x, M: int = 1)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

The Huber function

\[\begin{split}\operatorname{Huber}(x, M) = \begin{cases} 2M|x|-M^2 & \text{for } |x| \geq |M| \\ |x|^2 & \text{for } |x| \leq |M|. \end{cases}\end{split}\]

\(M\) defaults to 1.

Parameters

• x (Expression) – The expression to which the huber function will be applied.

• M (Constant) – A scalar constant.

inv_pos

cvxpy.atoms.elementwise.inv_pos.inv_pos(x)

\(x^{-1}\) for \(x > 0\).

kl_div

class cvxpy.atoms.elementwise.kl_div.kl_div(x, y)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

\(x\log(x/y) - x + y\)

For disambiguation between kl_div and rel_entr, see https://github.com/cvxpy/cvxpy/issues/733

log

class cvxpy.atoms.elementwise.log.log(x)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise \(\log x\).

log1p

class cvxpy.atoms.elementwise.log1p.log1p(x)

Bases: cvxpy.atoms.elementwise.log.log

Elementwise \(\log (1 + x)\).

logistic

class cvxpy.atoms.elementwise.logistic.logistic(x)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

\(\log(1 + e^{x})\)

This is a special case of log(sum(exp)) that is evaluates to a vector rather than to a scalar which is useful for logistic regression.

maximum

class cvxpy.atoms.elementwise.maximum.maximum(arg1, arg2, *args)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise maximum of a sequence of expressions.

minimum

cvxpy.atoms.elementwise.minimum.minimum(arg1, arg2, *args) → None

Elementwise minimum of a sequence of expressions.

neg

cvxpy.atoms.elementwise.neg.neg(x)

Alias for -minimum{x, 0}.

pos

cvxpy.atoms.elementwise.pos.pos(x)

Alias for maximum{x,0}.

power

class cvxpy.atoms.elementwise.power.power(x, p, max_denom: int = 1024)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

Elementwise power function \(f(x) = x^p\).

If expr is a CVXPY expression, then expr**p is equivalent to power(expr, p).

For DCP problems, the exponent p must be a numeric constant. For DGP problems, p can also be a scalar Parameter.

Specifically, the atom is given by the cases

\[\begin{split}\begin{array}{ccl} p = 0 & f(x) = 1 & \text{constant, positive} \\ p = 1 & f(x) = x & \text{affine, increasing, same sign as $x$} \\ p = 2,4,8,\ldots &f(x) = |x|^p & \text{convex, signed monotonicity, positive} \\ p < 0 & f(x) = \begin{cases} x^p & x > 0 \\ +\infty & x \leq 0 \end{cases} & \text{convex, decreasing, positive} \\ 0 < p < 1 & f(x) = \begin{cases} x^p & x \geq 0 \\ -\infty & x < 0 \end{cases} & \text{concave, increasing, positive} \\ p > 1,\ p \neq 2,4,8,\ldots & f(x) = \begin{cases} x^p & x \geq 0 \\ +\infty & x < 0 \end{cases} & \text{convex, increasing, positive}. \end{array}\end{split}\]

Note

For DCP problems, p cannot be represented exactly, so a rational, i.e., fractional, approximation must be made. (No such approximation is made for DGP problems.)

Internally, power computes a rational approximation to p with a denominator up to max_denom. Increasing max_denom can give better approximations.

When p is an int or Fraction object, the approximation is usually exact.

Note

The final domain, sign, monotonicity, and curvature of the power atom are determined by the rational approximation to p, not the input parameter p.

For example,

>>> from cvxpy import Variable, power
>>> x = Variable()
>>> g = power(x, 1.001)
>>> g.p
Fraction(1001, 1000)
>>> g
Expression(CONVEX, POSITIVE, (1, 1))
results in a convex atom with implicit constraint :math:`x \geq 0`, while
>>> g = power(x, 1.0001)
>>> g.p
1
>>> g
Expression(AFFINE, UNKNOWN, (1, 1))

results in an affine atom with no constraint on x.

• When \(p > 1\) and p is not a power of two, the monotonically increasing version of the function with full domain,

  \[\begin{split}f(x) = \begin{cases} x^p & x \geq 0 \\ 0 & x < 0 \end{cases}\end{split}\]

  can be formed with the composition power(pos(x), p).

• The symmetric version with full domain,

  \[f(x) = |x|^p\]

  can be formed with the composition power(abs(x), p).

Parameters

• x (cvxpy.Variable) –

• p (int, float, Fraction, or Parameter.) – Scalar power. p may be a Parameter in DGP programs, but not in DCP programs.

• max_denom (int) – The maximum denominator considered in forming a rational approximation of p; only relevant when solving as a DCP program.

rel-entr

class cvxpy.atoms.elementwise.rel_entr.rel_entr(x, y)

Bases: cvxpy.atoms.elementwise.elementwise.Elementwise

\(x\log(x/y)\)

For disambiguation between rel_entr and kl_div, see https://github.com/cvxpy/cvxpy/issues/733

scalene

cvxpy.atoms.elementwise.scalene.scalene(x, alpha, beta)

Alias for alpha*pos(x) + beta*neg(x).

sqrt

cvxpy.atoms.elementwise.sqrt.sqrt(x)

The square root of an expression.

square

cvxpy.atoms.elementwise.square.square(x)

The square of an expression.