casadi::OptiSol Class Reference

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:

Collaboration diagram for casadi::OptiSol:

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

Definition at line 861 of file optistack.cpp.

                                 : optistack_(opti) {
}

Member Function Documentation

disp()

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

Definition at line 864 of file optistack.cpp.

                                                      {
  optistack_.disp(stream, more);
}

References casadi::Opti::disp(), and optistack_.

get_str()

std::string casadi::OptiSol::get_str

(

bool

more = false

)

const

Definition at line 868 of file optistack.cpp.

                                          {
  return optistack_.get_str(more);
}

References casadi::Opti::get_str(), and optistack_.

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.

{ return optistack_; } // NOLINT(cppcoreguidelines-slicing)

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

Definition at line 890 of file optistack.cpp.

                          {
  return optistack_.stats();
}

References optistack_, and casadi::Opti::stats().

type_name()

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

inline

Definition at line 3566 of file optistack.hpp.

{return "OptiSol";}

value() [1/3]

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

Definition at line 875 of file optistack.cpp.

                                                                {
  return optistack_.value(x, values);
}

References optistack_, and casadi::Opti::value().

value() [2/3]

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

Definition at line 872 of file optistack.cpp.

                                                                {
  return optistack_.value(x, values);
}

References optistack_, and casadi::Opti::value().

value() [3/3]

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

Definition at line 878 of file optistack.cpp.

                                                                {
  return optistack_.value(x, values);
}

References optistack_, and casadi::Opti::value().

value_parameters()

std::vector< MX > casadi::OptiSol::value_parameters

(

)

const

Definition at line 886 of file optistack.cpp.

                                              {
  return optistack_.value_parameters();
}

References optistack_, and casadi::Opti::value_parameters().

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

Definition at line 882 of file optistack.cpp.

                                             {
  return optistack_.value_variables();
}

References optistack_, and casadi::Opti::value_variables().

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.

Referenced by disp(), get_str(), stats(), value(), value_parameters(), and value_variables().

---

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

• optistack.hpp
• optistack.cpp