Struct mop_blocks::gp::GpDefinitions

pub struct GpDefinitions<D, HCS, OS, SCS> { /* fields omitted */ }

Definitions for GP.

This structure is generic over single or multi objective problems, constrained or not.

Types

• D: Solution Domain
• HCS: Hard Constraints Storage
• OR: Objective Result
• OS: Objectives Storage
• S: Solution
• SCS: Soft Constraints Storage

Implementations

impl<D, HCS, OS, SCS> GpDefinitions<D, HCS, OS, SCS>

pub fn into_builder(self) -> GpDefinitionsBuilder<D, HCS, OS, SCS>

pub fn domain(&self) -> &D

pub fn name(&self) -> &str

impl<D, HC, HCS, OS, SCS> GpDefinitions<D, HCS, OS, SCS> where
    HCS: AsRef<[HC]> + Storage<Item = HC>, 

pub fn hard_cstrs(&self) -> &[HC]

Hard constraints

impl<D, HCS, O, SCS> GpDefinitions<D, HCS, [O; 1], SCS>

pub fn obj(&self) -> &O

Objective

impl<D, HCS, O, OS, SCS> GpDefinitions<D, HCS, OS, SCS> where
    OS: AsRef<[O]> + Storage<Item = O>, 

pub fn objs(&self) -> &[O]

Objectives

impl<D, HCS, OS, SC, SCS> GpDefinitions<D, HCS, OS, SCS> where
    SCS: AsRef<[SC]> + Storage<Item = SC>, 

pub fn soft_cstrs(&self) -> &[SC]

Soft constraints

Trait Implementations

impl<D: Clone, HCS: Clone, OS: Clone, SCS: Clone> Clone for GpDefinitions<D, HCS, OS, SCS>

fn clone(&self) -> GpDefinitions<D, HCS, OS, SCS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Debug, HCS: Debug, OS: Debug, SCS: Debug> Debug for GpDefinitions<D, HCS, OS, SCS>

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

Formats the value using the given formatter.

impl<D, HCS, OS, SCS> Default for GpDefinitions<D, HCS, OS, SCS> where
    D: Default,
    HCS: Default,
    SCS: Default,
    OS: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<AORS, AOS, ASS, BORS, BOS, D, HC, HCRS, HCS, OR, S, SS> GpOperations<GpDefinitions<D, HCS, AOS, ArrayVec<[(); 0]>>, GpOrs<HCRS, AORS, ArrayVec<[(); 0]>, ASS>, Gp<D, ArrayVec<[(); 0]>, ArrayVec<[(); 0]>, BORS, BOS, ArrayVec<[(); 0]>, ArrayVec<[(); 0]>, SS>> for MphMpMph where
    AORS: AsMut<[OR]> + Extend<OR> + Length<Output = usize> + Storage<Item = OR> + TraitCfg,
    AOS: TraitCfg,
    ASS: AsMut<[S]> + Push<Input = S> + Storage<Item = S> + TraitCfg,
    BORS: AsRef<[OR]> + Length<Output = usize> + Storage<Item = OR> + TraitCfg,
    BOS: TraitCfg,
    D: TraitCfg,
    HC: Cstr<S> + TraitCfg,
    HCRS: AsMut<[usize]> + Extend<usize> + Length<Output = usize> + Storage<Item = usize> + TraitCfg,
    HCS: AsRef<[HC]> + Storage<Item = HC> + TraitCfg,
    OR: Clone + Default + TraitCfg,
    S: Clone + TraitCfg,
    SS: AsRef<[S]> + Storage<Item = S> + TraitCfg, 

type Error = Error

fn convert(
    _: &MphDefinitions<D, HCS, AOS>
) -> Result<Mp<D, BORS, BOS, SS>, Self::Error>

fn transfer<'a>(
    a_defs: &'a MphDefinitions<D, HCS, AOS>,
    a_rslts: &'a mut MphOrs<HCRS, AORS, ASS>,
    b: &'a Mp<D, BORS, BOS, SS>
) -> SolverFuture<'a, Self::Error>

impl<AORS, AOS, ASS, BORS, BOS, D, HC, HCRS, HCS, OR, S, SCRS, SCS, SS> GpOperations<GpDefinitions<D, HCS, AOS, SCS>, GpOrs<HCRS, AORS, SCRS, ASS>, Gp<D, ArrayVec<[(); 0]>, ArrayVec<[(); 0]>, BORS, BOS, ArrayVec<[(); 0]>, ArrayVec<[(); 0]>, SS>> for MphsMpMphs where
    AORS: AsMut<[OR]> + Extend<OR> + Length<Output = usize> + Storage<Item = OR> + TraitCfg,
    AOS: TraitCfg,
    ASS: AsMut<[S]> + Push<Input = S> + Storage<Item = S> + TraitCfg,
    BORS: AsRef<[OR]> + Length<Output = usize> + Storage<Item = OR> + TraitCfg,
    BOS: TraitCfg,
    D: TraitCfg,
    HC: Cstr<S> + TraitCfg,
    HCRS: AsMut<[usize]> + Extend<usize> + Length<Output = usize> + Storage<Item = usize> + TraitCfg,
    HCS: AsRef<[HC]> + Storage<Item = HC> + TraitCfg,
    OR: Clone + Default + TraitCfg,
    S: Clone + TraitCfg,
    SCRS: AsMut<[usize]> + Extend<usize> + Length<Output = usize> + Storage<Item = usize> + TraitCfg,
    SCS: AsRef<[HC]> + Storage<Item = HC> + TraitCfg,
    SS: AsRef<[S]> + Storage<Item = S> + TraitCfg, 

type Error = Error

fn convert(
    _: &MphsDefinitions<D, HCS, AOS, SCS>
) -> Result<Mp<D, BORS, BOS, SS>, Self::Error>

fn transfer<'a>(
    a_defs: &'a MphsDefinitions<D, HCS, AOS, SCS>,
    a_rslts: &'a mut MphsOrs<HCRS, AORS, SCRS, ASS>,
    b: &'a Mp<D, BORS, BOS, SS>
) -> SolverFuture<'a, Self::Error>