Struct Solution 

#[non_exhaustive]
pub struct Solution {
    pub state: Option<State>,
    pub objective: f64,
    pub decision_variables: Vec<DecisionVariable>,
    pub evaluated_constraints: Vec<EvaluatedConstraint>,
    pub evaluated_named_functions: Vec<EvaluatedNamedFunction>,
    pub feasible: bool,
    pub feasible_relaxed: Option<bool>,
    pub feasible_unrelaxed: bool,
    pub optimality: i32,
    pub relaxation: i32,
    pub sense: i32,
}

Solution with evaluated objective and constraints

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

state: Option<State>

objective: f64

decision_variables: Vec<DecisionVariable>

evaluated_constraints: Vec<EvaluatedConstraint>

evaluated_named_functions: Vec<EvaluatedNamedFunction>

feasible: bool

The feasibility of the solution for all, remaining and removed constraints.

The feasibility for the remaining constraints is represented by the feasible_relaxed field.

feasible_relaxed: Option<bool>

Feasibility of the solution for remaining constraints, ignoring removed constraints.

This is optional due to the backward compatibility. If this field is NULL, the feasible field represents relaxed feasibility, and the deprecated feasible_unrelaxed field represents the feasibility including removed constraints.

feasible_unrelaxed: bool

👎Deprecated

[DEPRECATED] Feasibility of the solution for all constraints. This field has been introduced in Python SDK 1.6.0 and deprecated in 1.7.0. The feasibility in this sense is represented by the feasible field after 1.7.0.

optimality: i32

The optimality of the solution.

relaxation: i32

Whether the solution is obtained by a relaxed linear programming solver.

sense: i32

Whether the problem is a minimization or maximization problem.

Implementations

impl Solution

pub fn optimality(&self) -> Optimality

Returns the enum value of optimality, or the default if the field is set to an invalid enum value.

pub fn set_optimality(&mut self, value: Optimality)

Sets optimality to the provided enum value.

pub fn relaxation(&self) -> Relaxation

Returns the enum value of relaxation, or the default if the field is set to an invalid enum value.

pub fn set_relaxation(&mut self, value: Relaxation)

Sets relaxation to the provided enum value.

pub fn feasible_relaxed(&self) -> bool

Returns the value of feasible_relaxed, or the default value if feasible_relaxed is unset.

pub fn sense(&self) -> Sense

Returns the enum value of sense, or the default if the field is set to an invalid enum value.

pub fn set_sense(&mut self, value: Sense)

Sets sense to the provided enum value.

impl Solution

pub fn decision_variable_ids(&self) -> BTreeSet<u64>

pub fn constraint_ids(&self) -> BTreeSet<u64>

pub fn get_feasible_unrelaxed(&self) -> bool

pub fn get_feasible_relaxed(&self) -> bool

pub fn get_feasible(&self) -> bool

Trait Implementations

impl Clone for Solution

fn clone(&self) -> Solution

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Solution

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Solution

fn default() -> Self

Returns the “default value” for a type.

impl From<Solution> for Solution

fn from(solution: Solution) -> Self

Converts to this type from the input type.

impl Message for Solution

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl Parse for Solution

type Output = Solution

type Context = ()

fn parse(self, _: &Self::Context) -> Result<Self::Output, ParseError>

fn parse_as( self, context: &Self::Context, message: &'static str, field: &'static str, ) -> Result<Self::Output, ParseError>

impl PartialEq for Solution

fn eq(&self, other: &Solution) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Solution