|
| ( * ) [Sos.S] |
|
| ( * ) [Polynomial.S] |
|
| ( * ) [Matrix.S] |
|
| ( * ) [Lmi.S] |
|
| ( * ) [Scalar.S] |
|
| ( ** ) [Sos.S] |
|
| ( ** ) [Polynomial.S] |
|
| ( ** ) [Matrix.S] |
|
| ( ** ) [Lmi.S] |
|
| ( *. ) [Sos.S] |
|
| ( *. ) [Polynomial.S] |
|
| ( *. ) [Matrix.S] |
|
| ( *. ) [Lmi.S] |
|
| (!!) [Sos.S] |
|
| (!!) [Lmi.S] |
|
| (!) [Sos.S] |
|
| (!) [Polynomial.S] |
|
| (!) [Lmi.S] |
|
| (+) [Sos.S] |
|
| (+) [Polynomial.S] |
|
| (+) [Matrix.S] |
|
| (+) [Lmi.S] |
|
| (+) [Scalar.S] |
|
| (-) [Sos.S] |
|
| (-) [Polynomial.S] |
|
| (-) [Matrix.S] |
|
| (-) [Lmi.S] |
|
| (-) [Scalar.S] |
|
| (/) [Sos.S] |
|
| (/) [Polynomial.S] |
p / c is equivaent to mult_scalar (Coeff.div Coeff.one c)
p.
|
| (/) [Scalar.S] |
|
| (/.) [Sos.S] |
|
| (/.) [Polynomial.S] |
c1 /. c2 is equivaent to !c1 / c2.
|
| (<) [Scalar.S] |
|
| (<=) [Sos.S] |
e1 <= e2 is just syntactic sugar for e2 - e1.
|
| (<=) [Lmi.S] |
e1 <= e2 is just syntactic sugar for e2 - e1.
|
| (<=) [Scalar.S] |
|
| (<>) [Scalar.S] |
|
| (=) [Scalar.S] |
|
| (>) [Scalar.S] |
|
| (>=) [Sos.S] |
e1 >= e2 is just syntactic sugar for e1 - e2.
|
| (>=) [Lmi.S] |
e1 >= e2 is just syntactic sugar for e1 - e2.
|
| (>=) [Scalar.S] |
|
| (~-) [Sos.S] |
|
| (~-) [Polynomial.S] |
Unary minus, ~- p is syntactic sugar for sub zero p.
|
| (~-) [Matrix.S] |
|
| (~-) [Lmi.S] |
|
| (~-) [Scalar.S] |
|
| (~:) [Matrix.S] |
|
| (~:) [Lmi.S] |
|
| ?? [Sos.S] |
|
| ?? [Polynomial.S] |
|
A |
| add [Sos.S] |
|
| add [Scalar.M] |
|
| add [Polynomial.S] |
|
| add [Matrix.S] |
|
| add [Lmi.S] |
|
| add [LinExpr.S] |
|
B |
| block [Matrix.S] |
block a returns the block matrix corresponding to the array
a.
|
| block [Lmi.S] |
|
| block_diag_of_sparse [Sdp] |
|
| block_diag_to_sparse [Sdp] |
|
C |
| check [Sos.S] |
If check ?options e ?values (v, Q) returns true, then e is
SOS.
|
| check [Posdef] |
Takes as input a square matrix of Q.t of size nxn and returns 1 if it
manages to prove that the matrix is symmetric positive definite and 0
otherwise (i.e.
|
| check [Lmi.S] |
If check ?options e ?values returns true, then e is
positive semi-definite (PSD).
|
| check_PSD [Posdef] |
Same as check_complete but returns true iff the input is
positive *semi*definite (rather than positive definite).
|
| check_complete [Posdef] |
Same as check but complete (returns true iff the input is
positive definite).
|
| check_itv [Posdef] |
Takes as input a square interval matrix m of size nxn.
|
| check_round [Sos.S] |
|
| choose [LinExpr.S] |
Returns one of the (non zero) coefficients in the linear
expression (if any).
|
| compare [Scalar.M] |
|
| compare [Polynomial.S] |
|
| compare [Monomial] |
|
| compare [Ident] |
|
| compare [LinExpr.S] |
|
| compose [Sos.S] |
|
| compose [Polynomial.S] |
compose p [q_1;...; q_n] returns the polynomial p' such that
p'(x_1,..., x_m) = p(q_1(x_1,..., x_m),..., q_n(x_1,...,
x_m)).
|
| const [Sos.S] |
|
| const [Polynomial.S] |
const c is equivalent to var ~c ~d:0 0.
|
| const [Lmi.S] |
|
| const [LinExpr.S] |
|
| create [Ident] |
Create a new unique identificator.
|
D |
| default [Sos.S] |
|
| default [Sdpa] |
|
| default [Sdp] |
|
| default [Moseksdp] |
|
| default [Lmi.S] |
|
| default [Csdp] |
|
| degree [Sos.S] |
|
| degree [Polynomial.S] |
-1 for the null polynomial.
|
| degree [Monomial] |
|
| degree_list [Polynomial.S] |
degree_list p returns a list of length nb_vars p with the
maximal degree for each variable in p.
|
| derive [Sos.S] |
|
| derive [Polynomial.S] |
derive p i returns the derivative of the polynomial p with
respect to variable i (indices starting from 0).
|
| derive [Monomial] |
derive m i returns j_i, x_0^{j_0} ... x_i^{j_i - 1}
... x_n^{j_n}) if the degree j_i of variable i is positive in
the monomial m and 0, one otherwise.
|
| div [Scalar.M] |
|
| div [Monomial] |
div m1 m2 divides m1 by m2.
|
| divide [Monomial] |
divide m1 m2 returns true iff m1 divides m2 (i.e., when lcm
m1 m2 = m2 or equivalently gcd m1 m2 = m1).
|
E |
| empty_values [Lmi.S] |
empty_values () returns an empty map of values.
|
| equal [Scalar.S] |
|
| eval [Polynomial.S] |
eval p [x_1;...; x_n] returns p(x_1,..., x_n).
|
| eye [Matrix.S] |
eye n builds the identity matrix of size n (i.e., a square
matrix of size n with coefficients (i, j) equal to Coeff.of_int
O when i != j and Coeff.of_int 1 when i = j).
|
| eye [Lmi.S] |
|
F |
| filter [NewtonPolytope] |
filter s p returns the list of the s_i in s such that 2s_i is
in the convex hull of the p_1,..., p_n in p.
|
| float_of_q [Utils] |
float_of_q q returns a float closest to q.
|
| fold [Polynomial.S] |
|
G |
| gauss_split [Matrix.S] |
gauss_split m for a matrix m of size l x c returns (n, m1,
m2) where n is the rank of the input matrix (n <= l), m1
its row space, i.e., a matrix of size l' x c where l' <= l
characterizing the same space as m but with no linear
dependencies, and m2 a matrix of size l' x l mapping original
dimensions in m to the ones of m1 (m1 = m2 x m).
|
| gcd [Monomial] |
gcd m1 m2 returns the Greatest Common Divisor of m1 and m2
(i.e., the minimum of degrees for each variable).
|
| geq [Scalar.S] |
|
| gt [Scalar.S] |
|
I |
| inv [Scalar.S] |
|
| is_const [Polynomial.S] |
is_const p returns Some c if p is the constant polynomial
c and None otherwise.
|
| is_const [LinExpr.S] |
|
| is_homogeneous [Sos.S] |
|
| is_homogeneous [Polynomial.S] |
|
| is_monomial [Polynomial.S] |
is_monomial p returns Some m if p is a monmial x_0^i_0
...
|
| is_success [SdpRet] |
is_success t returns true if and only if t is Success or
PartialSuccess.
|
| is_symmetric [Matrix.S] |
|
| is_symmetric [Lmi.S] |
|
| is_var [Polynomial.S] |
is_var p returns Some (c, d, i) if p is a polynomial of
the form c xi^d and None otherwise.
|
| is_var [Monomial] |
is_var m returns Some (d, i) if m is the monomial xi^d and
None otherwise.
|
| is_var [LinExpr.S] |
|
| itv_float_of_q [Utils] |
itv_float_of_q q returns two floats l, u such that, when q is
Q.undef, l and u are both nan, otherwise l <= q <= u and
there is no float (either normal or subnormal) such that l < f < u.
|
K |
| kron [Matrix.S] |
kron n i j builds the square matrix of size n with all coefficients
equal to zero (i.e., Coeff.of_int 0 except coefficients (i, j) which is
one (i.e., Coeff.of_int 1).
|
| kron [Lmi.S] |
|
| kron_sym [Matrix.S] |
kron_sym n i j builds the square matrix of size n with
all coefficients equal to zero (i.e., Coeff.of_int 0 except
coefficients (i, j) and (j, i) which are one (i.e., Coeff.of_int
1).
|
| kron_sym [Lmi.S] |
|
L |
| lcm [Monomial] |
lcm m1 m2 returns the Least Common Multiple of m1 and m2
(i.e., the maximum of degrees for each variable).
|
| leq [Scalar.S] |
|
| lift_block [Matrix.S] |
lift_block m i j k l returns a matrix of size i x j with zeros
everywhere except starting from indices k x l where matrix m is
copied.
|
| lift_block [Lmi.S] |
|
| list_eq [Monomial] |
list_eq n d provides the list of all monomials with n
variables of degree equal d (for instance, list_eq 3 2 can
return [x0^2; x0 x1; x0 x2; x1^2; x1 x2; x2^2]).
|
| list_le [Monomial] |
list_le n d provides the list of all monomials with n
variables of degree less or equal d (for instance, list_le 3 2
can return [1; x0; x1; x2; x0^2; x0 x1; x0 x2; x1^2; x1 x2;
x2^2]).
|
| lt [Scalar.S] |
|
M |
| make [Sos.S] |
make s creates a new parametric variable named s.
|
| map [Utils] |
tail-recursive version of List.map (implemented using
List.rev_map and List.rev)
|
| matrix_of_sparse [Sdp] |
|
| matrix_to_sparse [Sdp] |
|
| merge [Polynomial.S] |
|
| minus [Matrix.S] |
|
| minus [Lmi.S] |
|
| minus_one [Scalar.S] |
|
| monomial [Sos.S] |
|
| monomial [Polynomial.S] |
monomial m is equivalent to of_list [m, Coeff.one].
|
| mult [Sos.S] |
|
| mult [Scalar.M] |
|
| mult [Polynomial.S] |
|
| mult [Monomial] |
mult m1 m2 multiplies the two monomials m1 and m2.
|
| mult [Matrix.S] |
|
| mult [Lmi.S] |
|
| mult_scalar [Sos.S] |
|
| mult_scalar [Polynomial.S] |
|
| mult_scalar [Matrix.S] |
mult_scalar s m multiplies matrix m by scalar s.
|
| mult_scalar [LinExpr.S] |
|
N |
| nb_cols [Matrix.S] |
|
| nb_cols [Lmi.S] |
|
| nb_lines [Matrix.S] |
|
| nb_lines [Lmi.S] |
|
| nb_vars [Sos.S] |
|
| nb_vars [Polynomial.S] |
nb_vars p returns the largest index (starting from 0) of a
variable appearing in p plus one (0 if none).
|
| nb_vars [Monomial] |
nb_vars m returns the largest index (starting from 0) of a
variable appearing in m plus one (0 if none).
|
| neg [Scalar.S] |
|
O |
| of_array_array [Matrix.S] |
of_array_array a returns the matrix with lines corresponding
to the elements of a.
|
| of_float [Scalar.M] |
|
| of_int [Scalar.S] |
|
| of_list [Sos.S] |
|
| of_list [Polynomial.S] |
of_list [(m_1, a_1);..; (m_n, a_n)] builds the polynomial
a_1 m_1 + ...
|
| of_list [Monomial] |
of_list l produces the monomial corresponding to list l.
|
| of_list [LinExpr.S] |
of_list [(x_1, a_1);..; (x_n, a_n)] c builds the affine
expression a_1 x_1 + ...
|
| of_list_list [Matrix.S] |
of_list_list l returns the matrix with lines corresponding to
the elements of the list l.
|
| of_q [Scalar.M] |
|
| one [Scalar.M] |
|
| one [Polynomial.S] |
|
| one [Monomial] |
Equivalent to of_list [].
|
P |
| param_vars [Sos.S] |
param_vars e returns the list of all parametric variables
appearing in e.
|
| pfeas_stop_crit [Sdp] |
pfeas_stop_crit (b_1,..., b_m) returns eps used as primal
feasibility error stopping criteria by solver solver on a
problem with given b_i (i.e., if the solver successfully
terminates, |tr(A_i X) - b_i| <= eps should hold for each
constraint i).
|
| power [Sos.S] |
|
| power [Polynomial.S] |
power p n computes p^n, n must be non negative.
|
| power [Matrix.S] |
power m n computes m^n, n must be non negative.
|
| power [Lmi.S] |
|
| pp [Sos.S] |
Printer for polynomial expressions.
|
| pp [SdpRet] |
|
| pp [Sdp] |
|
| pp [Scalar.M] |
|
| pp [Polynomial.S] |
|
| pp [Monomial] |
|
| pp [Matrix.S] |
|
| pp [Lmi.S] |
|
| pp [Ident] |
|
| pp [LinExpr.S] |
|
| pp_array [Utils] |
|
| pp_block_diag [Sdp] |
|
| pp_bounds [Sdp] |
|
| pp_constr [Sdp] |
|
| pp_constr_ext [Sdp] |
|
| pp_constr_ext [PreSdp.S] |
|
| pp_constr_ext [Dualize.S] |
|
| pp_ext [Sdp] |
|
| pp_ext_sedumi [Sdp] |
|
| pp_ext_sparse [Sdp] |
|
| pp_ext_sparse [PreSdp.S] |
|
| pp_ext_sparse [Dualize.S] |
|
| pp_ext_sparse_sedumi [Sdp] |
|
| pp_list [Utils] |
|
| pp_matrix [Utils] |
|
| pp_matrix [Sdp] |
|
| pp_names [Sos.S] |
|
| pp_names [Polynomial.S] |
|
| pp_names [Monomial] |
|
| pp_obj [Sdp] |
|
| pp_obj_ext [Sdp] |
|
| pp_obj_ext [PreSdp.S] |
|
| pp_obj_ext [Dualize.S] |
|
| pp_sparse [Sdp] |
|
| pp_sparse_matrix [Sdp] |
|
| pp_values [Lmi.S] |
Printer for environment values computed by solver.
|
| pp_vector [Sdp] |
|
| profile [Utils] |
profile f executes the function f and returns both its result
and the execution time in second.
|
R |
| register_value [Lmi.S] |
Register a scalar value in value environement
|
| remove [LinExpr.S] |
|
| remove_0_row_cols [Matrix.S] |
Returns the same matrix, without its rows and columns containing
only 0.
|
| replace [LinExpr.S] |
compose le [v_1, l_1;...; v_n, l_n] replaces each variable
v_i by l_i in l.
|
S |
| scalar [Sos.S] |
|
| scalar [Lmi.S] |
scalar s returns Const (Mat.of_list_list [[s]]).
|
| sdp_default [Sdp_default] |
|
| setround_tonearest [Utils] |
|
| sign [Scalar.S] |
Returns -1, 0 or 1 when its argument is respectively < 0, 0 or >
0.
|
| solve [Sos.S] |
solve obj l tries to optimise the objective obj under the
constraint that each polynomial expressions in l is SOS.
|
| solve [Sdpa] |
solve obj constraints solves the SDP problem: max{ tr(obj X) |
tr(A_1 X) = a_1,..., tr(A_n X) = a_n, X psd } with [(A_1,
a_1);...; (A_n, a_n)] the constraints list.
|
| solve [Sdp] |
|
| solve [Moseksdp] |
solve obj constraints solves the SDP problem: max{ tr(obj X) |
tr(A_1 X) = a_1,..., tr(A_m X) = a_m, X psd } with [(A_1,
a_1);...; (A_m, a_m)] the constraints list.
|
| solve [Lmi.S] |
solve obj l tries to optimise the objective obj under the
constraint that each matrix expressions in l is positive
semi-definite.
|
| solve [Csdp] |
solve ?verbose obj constraints solves the SDP problem: max{
tr(obj X) | tr(A_1 X) = a_1,..., tr(A_n X) = a_n, X psd } with
[(A_1, a_1);...; (A_n, a_n)] the constraints list.
|
| solve_ext [Sdp] |
|
| solve_ext [Moseksdp] |
solve obj constraints solves the SDP problem: max{ c^T x +
tr(obj X) | b_1^- <= a_1^T x + tr(A_1 X) <= a_1^+,..., b_m^- <=
a_m x + tr(A_m X) <= b_m^+, d_1^- <= x_1 <= d_1^+,..., d_n^- <=
x_n <= d_n^+, X psd } with [(a_1, A_1, b_1^-, b_1^+);...; (a_m,
A_m, b_m^-, b_m^+)] the constraints list and [(d_1^-,
d_1^+),..., (d_n^-, d_n^+)] the bounds list (missing bounds
are considered as (neg_infinity, infinity), bounds about
variables x_i not appearing in the objective or constraints may be
ignored).
|
| solve_ext_sparse [Sdp] |
solve_ext_sparse obj constraints bounds solves the SDP problem:
max{ obj | constraints, bounds, X psd }.
|
| solve_ext_sparse [PreSdp.S] |
|
| solve_ext_sparse [Dualize.S] |
|
| solve_ext_sparse_details [Dualize.S] |
|
| solve_sparse [Sdp] |
solve_sparse obj constraints solves the SDP problem: max{
tr(obj X) | constraints, X psd }.
|
| string_of_float_bin [Posdef] |
|
| sub [Sos.S] |
|
| sub [Scalar.M] |
|
| sub [Polynomial.S] |
|
| sub [Matrix.S] |
|
| sub [Lmi.S] |
|
| sub [LinExpr.S] |
|
T |
| to_array_array [Matrix.S] |
The returned array is a copy that can be freely modified by the
user.
|
| to_float [Scalar.M] |
|
| to_list [Sos.S] |
Returns a list sorted in increasing order of
Monomial.compare without
duplicates.
|
| to_list [Polynomial.S] |
Returns a list sorted in increasing order of
Monomial.compare without
duplicates nor zeros.
|
| to_list [Monomial] |
The returned list contains only non negative values and its last
element is non zero (or the list is empty).
|
| to_list [LinExpr.S] |
Returns a list sorted in increasing order of
Ident.compare without duplicates nor
zeros.
|
| to_list_list [Matrix.S] |
|
| to_q [Scalar.M] |
|
| transpose [Matrix.S] |
|
| transpose [Lmi.S] |
|
V |
| value [Sos.S] |
value e values returns the evaluation of polynomial expression
e, replacing all Var by the correspoding value in values.
|
| value [Lmi.S] |
value e values returns the evaluation of matrix expression
e, replacing all Var by the corresponding value in values.
|
| value_mat [Lmi.S] |
value_mat e values returns the evaluation of matrix expression
e, replacing all Var by the correspoding value in values.
|
| value_poly [Sos.S] |
value_poly e values returns the evaluation of polynomial
expression e, replacing all Var by the correspoding value in
values.
|
| var [Polynomial.S] |
var ?c ?d i returns c xi^d, this is equivalent to of_list [c,
Monomial.var ~d i].
|
| var [Monomial] |
var ?d i returns xi^d, this is equivalent to of_list [0;...; O;
d] with i zeros.
|
| var [Lmi.S] |
var s n creates a new variable (Var v).
|
| var [LinExpr.S] |
|
| var_var [Lmi.S] |
TODO: renamed (to discuss: this breaks the interface)
|
Z |
| zero [Scalar.M] |
|
| zero [Polynomial.S] |
|
| zeros [Matrix.S] |
zeros n m builds a matrix of size n x m with all coefficients
equal to Coeff.of_int O.
|
| zeros [Lmi.S] |
|