Snapshot of an Opti problem and its solution. More...

#include <optistack.hpp>

Detailed Description

Returned by Opti::solve and Opti::solve_limited. It is a deep copy made at that moment: later set_value/set_initial/subject_to calls on the Opti do not change what value() returns, so several OptiSol objects can be kept and compared. The API is guaranteed to be stable.

>>> opti = Opti()
>>> x = opti.variable()
>>> p = opti.parameter()
>>> opti.minimize((x-p)**2)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> opti.set_value(p, 1)
>>> sol1 = opti.solve()
>>> opti.set_value(p, 2)
>>> sol2 = opti.solve()
>>> sol1.value(x), sol2.value(x)
(1.0, 2.0)

>> opti = Opti(); x = opti.variable(); p = opti.parameter();
>> opti.minimize((x-p)^2);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> opti.set_value(p, 1); sol1 = opti.solve();
>> opti.set_value(p, 2); sol2 = opti.solve();
>> sol1.value(x), sol2.value(x)
1
2

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> p = ca.parameter(opti);
julia> ca.minimize(opti, (x - p)^2)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> ca.set_value(opti, p, 1)
julia> sol1 = ca.solve(opti);
julia> ca.set_value(opti, p, 2)
julia> sol2 = ca.solve(opti);
julia> ca.value(sol1, x), ca.value(sol2, x)
(1.0, 2.0)

Date: 2017

Author: Joris Gillis, Erik Lambrechts

Extra doc: https://github.com/casadi/casadi/wiki/L_1v

Definition at line 3563 of file optistack.hpp.

Inheritance diagram for casadi::OptiSol:

[legend]

Public Member Functions
std::string	type_name () const

void	disp (std::ostream &stream, bool more=false) const

std::string	get_str (bool more=false) const

std::vector< MX >	value_variables () const
	Get assignment expressions for the optimal solution. More...

std::vector< MX >	value_parameters () const

Dict	stats () const
	Get the solver statistics of this solve. More...

Opti	opti () const
	Get the Opti copy this solution belongs to. More...


native_DM	value (const MX &x, const std::vector< MX > &values=std::vector< MX >()) const
	Evaluate an expression at the solution. More...

native_DM	value (const DM &x, const std::vector< MX > &values=std::vector< MX >()) const
	Evaluate an expression at the solution. More...

native_DM	value (const SX &x, const std::vector< MX > &values=std::vector< MX >()) const
	Evaluate an expression at the solution. More...

Protected Member Functions
	OptiSol (const Opti &opti)

Protected Attributes
OptiAdvanced	optistack_

Friends
class	OptiNode

Constructor & Destructor Documentation

◆ OptiSol()

casadi::OptiSol::OptiSol ( const Opti & opti )

protected

Member Function Documentation

◆ disp()

void casadi::OptiSol::disp	(	std::ostream &	stream,
		bool	more = `false`
	)		const

◆ get_str()

std::string casadi::OptiSol::get_str ( bool more = false ) const

◆ opti()

Opti casadi::OptiSol::opti ( ) const

inline

An Opti holding the state at the time of the solve; opti.debug on it gives the OptiAdvanced accessors. In Python this is a read-only property.

>>> opti = Opti()
>>> x = opti.variable()
>>> opti.minimize((x-1)**2)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> sol.opti.return_status(), sol.opti.debug.value(x)
('Solve_Succeeded', 1.0)

>> opti = Opti(); x = opti.variable(); opti.minimize((x-1)^2);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve(); o = sol.opti;
>> o.return_status(), o.debug.value(x)
Solve_Succeeded
1

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> ca.minimize(opti, (x - 1)^2)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> ca.return_status(ca.opti(sol)), ca.value(ca.debug(ca.opti(sol)), x)
("Solve_Succeeded", 1.0)

Extra doc: https://github.com/casadi/casadi/wiki/L_2nf

Definition at line 3799 of file optistack.hpp.

◆ stats()

Dict casadi::OptiSol::stats ( ) const

The dict returned by the nlpsol/qpsol plugin, passed as-is ("success", "return_status", "iter_count", ...). No stability is guaranteed for the entries.

>>> opti = Opti()
>>> x = opti.variable()
>>> opti.minimize((x-1)**2)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> sol.stats()["success"], sol.stats()["return_status"]
(True, 'Solve_Succeeded')

>> opti = Opti(); x = opti.variable(); opti.minimize((x-1)^2);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve(); s = sol.stats(); disp(s.success), disp(s.return_status)
1
Solve_Succeeded

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> ca.minimize(opti, (x - 1)^2)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> ca.stats(sol)["success"], ca.stats(sol)["return_status"]
(true, "Solve_Succeeded")

Extra doc: https://github.com/casadi/casadi/wiki/L_1w

◆ type_name()

std::string casadi::OptiSol::type_name ( ) const

inline

Definition at line 3566 of file optistack.hpp.

◆ value() [1/3]

native_DM casadi::OptiSol::value	(	const DM &	x,
		const std::vector< MX > &	values = `std::vector< MX >()`
	)		const

Same as Opti::value on the snapshot: variables take their optimal values, parameters the values used for the solve, dual variables the multipliers. values overrules individual symbols for this evaluation only, e.g. opti.initial() to evaluate at the initial guess.

Parameters

x	Expression (MX) in the symbols of the Opti; a DM is returned as is
values	Optional list of assignments var==value

A scalar becomes a float, a dense matrix a numpy array and a sparse matrix a scipy sparse matrix.

>>> opti = Opti()
>>> x = opti.variable()
>>> y = opti.variable()
>>> opti.minimize((y-x**2)**2)
>>> opti.subject_to(x**2+y**2==1)
>>> opti.subject_to(x+y>=1)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> sol.value(x), sol.value(vertcat(x, y)).shape
(0.7862, (2,))
>>> sol.value(opti.f, [y==2])
1.9098
>>> sol.value(x**2+y, opti.initial())
0.0
>>> sol.value(jacobian(opti.g, opti.x)).shape
(2, 2)

The value is a double matrix, sparse when the expression is sparse.

>> opti = Opti(); x = opti.variable(); y = opti.variable();
>> opti.minimize((y-x^2)^2); opti.subject_to(x^2+y^2==1); opti.subject_to(x+y>=1);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve();
>> sol.value(x), size(sol.value(vertcat(x, y)))
0.7862
2 1
>> sol.value(opti.f, {y==2})
1.9098
>> sol.value(x^2+y, opti.initial())
0
>> size(sol.value(jacobian(opti.g, opti.x)))
2 2

A scalar becomes a Float64, any other value a dense Matrix{Float64}.

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> y = ca.variable(opti);
julia> ca.minimize(opti, (y - x^2)^2)
julia> ca.subject_to(opti, x^2 + y^2 == 1)
julia> ca.subject_to(opti, x + y >= 1)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> ca.value(sol, x), size(ca.value(sol, [x; y]))
(0.7862, (2,))
julia> sol.value(ca.f(opti), [y == 2])
1.9098
julia> sol.value(x^2 + y, ca.initial(opti))
0.0
julia> size(ca.value(sol, ca.jacobian(ca.g(opti), ca.x(opti))))
(2, 2)

Extra doc: https://github.com/casadi/casadi/wiki/L_2nd

◆ value() [2/3]

native_DM casadi::OptiSol::value	(	const MX &	x,
		const std::vector< MX > &	values = `std::vector< MX >()`
	)		const

Same as Opti::value on the snapshot: variables take their optimal values, parameters the values used for the solve, dual variables the multipliers. values overrules individual symbols for this evaluation only, e.g. opti.initial() to evaluate at the initial guess.

Parameters

x	Expression (MX) in the symbols of the Opti; a DM is returned as is
values	Optional list of assignments var==value

A scalar becomes a float, a dense matrix a numpy array and a sparse matrix a scipy sparse matrix.

>>> opti = Opti()
>>> x = opti.variable()
>>> y = opti.variable()
>>> opti.minimize((y-x**2)**2)
>>> opti.subject_to(x**2+y**2==1)
>>> opti.subject_to(x+y>=1)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> sol.value(x), sol.value(vertcat(x, y)).shape
(0.7862, (2,))
>>> sol.value(opti.f, [y==2])
1.9098
>>> sol.value(x**2+y, opti.initial())
0.0
>>> sol.value(jacobian(opti.g, opti.x)).shape
(2, 2)

The value is a double matrix, sparse when the expression is sparse.

>> opti = Opti(); x = opti.variable(); y = opti.variable();
>> opti.minimize((y-x^2)^2); opti.subject_to(x^2+y^2==1); opti.subject_to(x+y>=1);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve();
>> sol.value(x), size(sol.value(vertcat(x, y)))
0.7862
2 1
>> sol.value(opti.f, {y==2})
1.9098
>> sol.value(x^2+y, opti.initial())
0
>> size(sol.value(jacobian(opti.g, opti.x)))
2 2

A scalar becomes a Float64, any other value a dense Matrix{Float64}.

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> y = ca.variable(opti);
julia> ca.minimize(opti, (y - x^2)^2)
julia> ca.subject_to(opti, x^2 + y^2 == 1)
julia> ca.subject_to(opti, x + y >= 1)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> ca.value(sol, x), size(ca.value(sol, [x; y]))
(0.7862, (2,))
julia> sol.value(ca.f(opti), [y == 2])
1.9098
julia> sol.value(x^2 + y, ca.initial(opti))
0.0
julia> size(ca.value(sol, ca.jacobian(ca.g(opti), ca.x(opti))))
(2, 2)

Extra doc: https://github.com/casadi/casadi/wiki/L_2nd

◆ value() [3/3]

native_DM casadi::OptiSol::value	(	const SX &	x,
		const std::vector< MX > &	values = `std::vector< MX >()`
	)		const

Same as Opti::value on the snapshot: variables take their optimal values, parameters the values used for the solve, dual variables the multipliers. values overrules individual symbols for this evaluation only, e.g. opti.initial() to evaluate at the initial guess.

Parameters

x	Expression (MX) in the symbols of the Opti; a DM is returned as is
values	Optional list of assignments var==value

A scalar becomes a float, a dense matrix a numpy array and a sparse matrix a scipy sparse matrix.

>>> opti = Opti()
>>> x = opti.variable()
>>> y = opti.variable()
>>> opti.minimize((y-x**2)**2)
>>> opti.subject_to(x**2+y**2==1)
>>> opti.subject_to(x+y>=1)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> sol.value(x), sol.value(vertcat(x, y)).shape
(0.7862, (2,))
>>> sol.value(opti.f, [y==2])
1.9098
>>> sol.value(x**2+y, opti.initial())
0.0
>>> sol.value(jacobian(opti.g, opti.x)).shape
(2, 2)

The value is a double matrix, sparse when the expression is sparse.

>> opti = Opti(); x = opti.variable(); y = opti.variable();
>> opti.minimize((y-x^2)^2); opti.subject_to(x^2+y^2==1); opti.subject_to(x+y>=1);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve();
>> sol.value(x), size(sol.value(vertcat(x, y)))
0.7862
2 1
>> sol.value(opti.f, {y==2})
1.9098
>> sol.value(x^2+y, opti.initial())
0
>> size(sol.value(jacobian(opti.g, opti.x)))
2 2

A scalar becomes a Float64, any other value a dense Matrix{Float64}.

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> y = ca.variable(opti);
julia> ca.minimize(opti, (y - x^2)^2)
julia> ca.subject_to(opti, x^2 + y^2 == 1)
julia> ca.subject_to(opti, x + y >= 1)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> ca.value(sol, x), size(ca.value(sol, [x; y]))
(0.7862, (2,))
julia> sol.value(ca.f(opti), [y == 2])
1.9098
julia> sol.value(x^2 + y, ca.initial(opti))
0.0
julia> size(ca.value(sol, ca.jacobian(ca.g(opti), ca.x(opti))))
(2, 2)

Extra doc: https://github.com/casadi/casadi/wiki/L_2nd

◆ value_parameters()

std::vector<MX> casadi::OptiSol::value_parameters ( ) const

◆ value_variables()

std::vector<MX> casadi::OptiSol::value_variables ( ) const

value_variables() gives value==var for every variable, value_parameters() value==par for every parameter. Pass them to Opti::set_initial / Opti::set_value to warm start the next solve.

>>> opti = Opti()
>>> x = opti.variable()
>>> p = opti.parameter()
>>> opti.minimize((x-p)**2)
>>> opti.set_value(p, 2)
>>> opti.solver("ipopt", {"print_time": False}, {"print_level": 0, "sb": "yes"})
>>> sol = opti.solve()
>>> print(sol.value_variables(), sol.value_parameters())
[MX((2==opti..._x_1))] [MX((2==opti..._p_1))]
>>> opti.set_initial(sol.value_variables())
>>> opti.solve().stats()["iter_count"]
0

>> opti = Opti(); x = opti.variable(); p = opti.parameter();
>> opti.minimize((x-p)^2); opti.set_value(p, 2);
>> opti.solver('ipopt', struct('print_time', false), struct('print_level', 0, 'sb', 'yes'));
>> sol = opti.solve();
>> vv = sol.value_variables(); vp = sol.value_parameters(); disp(vv{1}), disp(vp{1})
(2==opti..._x_1)
(2==opti..._p_1)
>> opti.set_initial(sol.value_variables()); sol2 = opti.solve();
>> s = sol2.stats(); disp(s.iter_count)
0

julia> opti = ca.Opti();
julia> x = ca.variable(opti);
julia> p = ca.parameter(opti);
julia> ca.minimize(opti, (x - p)^2)
julia> ca.set_value(opti, p, 2)
julia> ca.solver(opti, "ipopt", Dict("print_time" => false),
                  Dict("print_level" => 0, "sb" => "yes"))
julia> sol = ca.solve(opti);
julia> print(ca.value_variables(sol), " ", ca.value_parameters(sol))
MX[(2==opti..._x_1)] MX[(2==opti..._p_1)]
julia> opti.set_initial(ca.value_variables(sol))
julia> ca.stats(ca.solve(opti))["iter_count"]
0

Extra doc: https://github.com/casadi/casadi/wiki/L_2ne

Friends And Related Function Documentation

◆ OptiNode

friend class OptiNode

friend

Definition at line 3564 of file optistack.hpp.

Member Data Documentation

◆ optistack_

OptiAdvanced casadi::OptiSol::optistack_

protected

Definition at line 3803 of file optistack.hpp.

The documentation for this class was generated from the following file:

optistack.hpp

Detailed Description

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Constructor & Destructor Documentation

◆ OptiSol()

Member Function Documentation

◆ disp()

◆ get_str()

◆ opti()

◆ stats()

◆ type_name()

◆ value() [1/3]

◆ value() [2/3]

◆ value() [3/3]

◆ value_parameters()

◆ value_variables()

Friends And Related Function Documentation

◆ OptiNode

Member Data Documentation

◆ optistack_