GradientConfig(f::Polynomial{T}, [x::AbstractVector{S}])

A data structure with which the gradient of a Polynomialf can be evaluated efficiently. Note that x is only used to determine the output type of f(x).

GradientConfig(f::Polynomial{T}, [S])

Instead of a vector x a type can also be given directly.

GradientDiffResult(cfg::GradientConfig)

During the computation of $∇g(x)$ we compute nearly everything we need for the evaluation of $g(x)$. GradientDiffResult allocates memory to hold both values. This structure also signals gradient! to store $g(x)$ and $∇g(x)$.

Example

cfg = GradientConfig(g, x)
r = GradientDiffResult(cfg)
gradient!(r, g, x, cfg)

value(r) == g(x)
gradient(r) == gradient(g, x, cfg)

GradientDiffResult(grad::AbstractVector)

Allocate the memory to hold the gradient by yourself.

JacobianConfig(F::Vector{Polynomial{T}}, [x::AbstractVector{S}])

A data structure with which the jacobian of a VectorF of Polynomials can be evaluated efficiently. Note that x is only used to determine the output type of F(x).

JacobianConfig(F::Vector{Polynomial{T}}, [S])

Instead of a vector x a type can also be given directly.

JacobianDiffResult(cfg::GradientConfig)

During the computation of the jacobian $J_F(x)$ we compute nearly everything we need for the evaluation of $F(x)$. JacobianDiffResult allocates memory to hold both values. This structure also signals jacobian! to store $F(x)$ and $J_F(x)$.

Example

cfg = JacobianConfig(F, x)
r = JacobianDiffResult(cfg)
jacobian!(r, F, x, cfg)

value(r) == map(f -> f(x), F)
jacobian(r) == jacobian(F, x, cfg)

JacobianDiffResult(value::AbstractVector, jacobian::AbstractMatrix)

Allocate the memory to hold the value and the jacobian by yourself.

Polynomial(p::MultivariatePolynomials.AbstractPolynomial [, variables [, homogenized=false]])

A structure for fast evaluation of multivariate polynomials. The terms are sorted first by total degree, then lexicographically. Polynomial has first class support for homogenous polynomials. This field indicates whether the first variable should be considered as the homogenization variable.

Polynomial{T}(p::MultivariatePolynomials.AbstractPolynomial [, variables [, homogenized=false]])

You can force a coefficient type T. For optimal performance T should be same type as the input to with which it will be evaluated.

Polynomial(exponents::Matrix{Int}, coefficients::Vector{T}, variables, [, homogenized=false])

You can also create a polynomial directly. Note that in exponents each column represents the exponent of a term.

Example

Poly([3 1; 1 1; 0 2 ], [-2.0, 3.0], [:x, :y, :z]) == 3.0x^2yz^2 - 2x^3y

System(polys [, variables])

Construct a system of polynomials from the given polynomials polys.

coefficients(p::Polynomial)

Returns the coefficient vector of p.

config(F::Polynomial, x)

Construct a GradientConfig for the evaluation of f with values like x.

config(F::System, x)

Construct a JacobianConfig for the evaluation of F with values like x.

degree(p::Polynomial)

Returns the (total) degree of p.

dehomogenize(p::Polynomial)

Substitute 1 as for the first variable p, if ishomogenized(p) is false this is just the identity.

differentiate(p::Polynomial, varindex::Int)

Differentiate p w.r.t the varindexth variable.

differentiate(p::Polynomial)

Differentiate p w.r.t. all variables.

evaluate!(u, F, x, cfg::JacobianConfig [, precomputed=false])

Evaluate the system F at x using the precomputated values in cfg and store the result in u. Note that this is usually signifcant faster than map!(u, f -> evaluate(f, x), F).

Example

cfg = JacobianConfig(F)
evaluate!(u, F, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or jacobian with the same x.

evaluate(g, x, cfg::GradientConfig [, precomputed=false])

Evaluate g at x using the precomputated values in cfg. Note that this is usually signifcant faster than evaluate(g, x).

Example

cfg = GradientConfig(g)
evaluate(g, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or gradient with the same x.

evaluate(F, x, cfg::JacobianConfig [, precomputed=false])

Evaluate the system F at x using the precomputated values in cfg. Note that this is usually signifcant faster than map(f -> evaluate(f, x), F). The return vector is constructed using similar(x, T).

Example

cfg = JacobianConfig(F)
evaluate(F, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or jacobian with the same x.

evaluate(p::Polynomial{T}, x::AbstractVector{T})

Evaluates p at x, i.e. $p(x)$. Polynomial is also callable, i.e. you can also evaluate it via p(x).

evaluate_and_jacobian!(u, U, F, x, cfg::JacobianConfig)

Evaluate F and its Jacobian at x using the precomputated values in cfg and store the result in u and U (Jacobian).

Example

evaluate_and_jacobian!(u, U, F, x, config(F, x))

exponents(p::Polynomial)

Returns the exponents matrix of p. Each column represents the exponents of a term of p.

gradient!(u, g, x, cfg::GradientConfig [, precomputed=false])

Compute the gradient of g at x using the precomputated values in cfg and store thre result in u.

Example

cfg = GradientConfig(g)
gradient(u, g, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or gradient with the same x.

gradient!(r::GradientDiffResult, g, x, cfg::GradientConfig)

Compute $g(x)$ and the gradient of g at x at once using the precomputated values in cfg and store thre result in r. This is faster than calling both values separetely.

Example

cfg = GradientConfig(g)
r = GradientDiffResult(r)
gradient!(r, g, x, cfg)

value(r) == g(x)
gradient(r) == gradient(g, x, cfg)

homogenize(p::Polynomial [, variable = :x0])

Makes p homogenous, if ishomogenized(p) is true this is just the identity. The homogenization variable will always be considered as the first variable of the polynomial.

ishomogenized(p::Polynomial)

Checks whether p was homogenized.

ishomogenous(p::Polynomial)

Checks whether p is a homogenous polynomial. Note that this is unaffected from the value of homogenized(p).

jacobian!(u, F, x, cfg::JacobianConfig [, precomputed=false])

Evaluate the jacobian of F at x using the precomputated values in cfg and store the result in u.

Example

cfg = JacobianConfig(F)
jacobian!(u, F, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or jacobian with the same x.

jacobian!(r::JacobianDiffResult, F, x, cfg::JacobianConfig)

Compute $F(x)$ and the jacobian of F at x at once using the precomputated values in cfg and store thre result in r. This is faster than computing both values separetely.

Example

cfg = GradientConfig(g)
r = GradientDiffResult(cfg)
gradient!(r, g, x, cfg)

value(r) == g(x)
gradient(r) == gradient(g, x, cfg)

jacobian(u, F, x, cfg::JacobianConfig [, precomputed=false])

Evaluate the jacobian of F at x using the precomputated values in cfg. The return matrix is constructed using similar(x, T, m, n).

Example

cfg = JacobianConfig(F)
jacobian(F, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or jacobian with the same x.

nterms(p::Polynomial)

Returns the number of terms of p

nvariables(p::Polynomial)

Returns the number of variables of p

nvariables(F::System)

Returns the number of variables of F.

scale_coefficients!(f::Polynomial, λ)

Scale the coefficients of f with the factor λ.

substitute(p::Polynomial, i, x)

In p substitute for the variable with index i the value x. You can use this for partial evaluation of polynomial.

Example

julia> substitute(x^2+3y, 2, 5)
x^2+15

value(r::GradientDiffResult)

Get the currently stored value in r.

variables(p::Polynomial)

Returns the variables of p.

weyldot(f::Polynomial, g::Polynomial)

Compute the Bombieri-Weyl dot product. Note that this is only properly defined if f and g are homogenous.

weyldot(f::Vector{Polynomial}, g::Vector{Polynomial})

Compute the dot product for vectors of polynomials.

weylnorm(f::Polynomial)

Compute the Bombieri-Weyl norm. Note that this is only properly defined if f is homogenous.

∇(p::Polynomial)

Returns the gradient vector of p. This is the same as differentiate.

gradient(r::GradientDiffResult)

Get the currently stored gradient in r.

gradient(g, x, cfg::GradientConfig[, precomputed=false])

Compute the gradient of g at x using the precomputated values in cfg. The return vector is constructed using similar(x, T).

Example

cfg = GradientConfig(g)
gradient(g, x, cfg)

With precomputed=true we rely on the previous intermediate results in cfg. Therefore the result is only correct if you previouls called evaluate, or gradient with the same x.

gradient_row!(u::AbstractMatrix, x::AbstractVector, cfg::PolyConfig{T}, i)

Store the gradient in the i-th row of 'u'.

Sorts two vectory by total degree

Computes the multinomial coefficient (|k| \over k)