Struct mop_blocks::gp::GpOrs

pub struct GpOrs<HCRS, ORS, SCRS, SS> { /* fields omitted */ }

MPH-ORS (Multi-objective Problem with Hard constraint - Optimization ResultS)

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

Types

• CRS: Constraint Results Storage
• ORS: Objectives Results Storage
• ORAS: Objective Results Average Storage
• SS: Solutions Storage

Implementations

impl<HCRS, ORS, SCRS, SS> GpOrs<HCRS, ORS, SCRS, SS>

pub fn clear(&mut self) where
    HCRS: Clear,
    ORS: Clear,
    SCRS: Clear,
    SS: Clear, 

pub fn truncate(&mut self, until_idx: usize) where
    HCRS: Truncate<Input = usize>,
    ORS: Truncate<Input = usize>,
    SCRS: Truncate<Input = usize>,
    SS: Truncate<Input = usize>, 

pub fn rslts_num(&self) -> usize

impl<HCR, HCRS, OR, ORS, S, SCR, SCRS, SS> GpOrs<HCRS, ORS, SCRS, SS> where
    HCRS: Storage<Item = HCR>,
    ORS: Storage<Item = OR>,
    SCRS: Storage<Item = SCR>,
    SS: Storage<Item = S>, 

pub fn constructor(&mut self) -> GpOrsConstructor<HCRS, ORS, SCRS, SS>

impl<HCR, HCRS, OR, ORS, S, SCR, SCRS, SS> GpOrs<HCRS, ORS, SCRS, SS> where
    HCRS: AsMut<[HCR]> + Storage<Item = HCR>,
    ORS: AsMut<[OR]> + Storage<Item = OR>,
    SCRS: AsMut<[SCR]> + Storage<Item = SCR>,
    SS: AsMut<[S]> + Storage<Item = S>, 

pub fn get_mut(&mut self, idx: usize) -> Option<GpOrMut<HCR, OR, S, SCR>>

pub fn get_two_mut(
    &mut self,
    a: usize,
    b: usize
) -> Option<[GpOrMut<HCR, OR, S, SCR>; 2]>

pub fn iter_mut<'a>(
    &'a mut self
) -> impl Iterator<Item = GpOrMut<'a, HCR, OR, S, SCR>> where
    HCR: 'a,
    OR: 'a,
    S: 'a,
    SCR: 'a, 

pub fn remove(&mut self, idx: usize) where
    HCRS: Truncate<Input = usize>,
    SCRS: Truncate<Input = usize>,
    ORS: Truncate<Input = usize>,
    SS: Remove<Input = usize>, 

pub fn swap(&mut self, a: usize, b: usize)

impl<HCR, HCRS, OR, ORS, S, SCR, SCRS, SS> GpOrs<HCRS, ORS, SCRS, SS> where
    HCRS: AsRef<[HCR]> + Storage<Item = HCR>,
    ORS: AsRef<[OR]> + Storage<Item = OR>,
    SCRS: AsRef<[SCR]> + Storage<Item = SCR>,
    SS: AsRef<[S]> + Storage<Item = S>, 

pub fn as_ref(&self) -> GpOrsRef<HCR, OR, S, SCR>

pub fn get(&self, idx: usize) -> Option<GpOrRef<HCR, OR, S, SCR>>

pub fn iter<'a>(&'a self) -> impl Iterator<Item = GpOrRef<'a, HCR, OR, S, SCR>> where
    HCR: 'a,
    OR: 'a,
    S: 'a,
    SCR: 'a, 

impl<HCR, HCRS, OR, ORS, S, SCR, SCRS, SS> GpOrs<HCRS, ORS, SCRS, SS> where
    HCRS: Storage<Item = HCR> + WithCapacity<Input = usize>,
    ORS: Storage<Item = OR> + WithCapacity<Input = usize>,
    SCRS: Storage<Item = SCR> + WithCapacity<Input = usize>,
    SS: Storage<Item = S> + WithCapacity<Input = usize>, 

pub fn with_capacity<HC, HCS, D, O, OS, SC, SCS>(
    defs: &GpDefinitions<D, HCS, OS, SCS>,
    rslts_num: usize
) -> Self where
    HCS: AsRef<[HC]> + Storage<Item = HC>,
    OS: AsRef<[O]> + Storage<Item = O>,
    SCS: AsRef<[SC]> + Storage<Item = SC>, 

Trait Implementations

impl<HCRS: Clone, ORS: Clone, SCRS: Clone, SS: Clone> Clone for GpOrs<HCRS, ORS, SCRS, SS>

fn clone(&self) -> GpOrs<HCRS, ORS, SCRS, SS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<HCRS: Debug, ORS: Debug, SCRS: Debug, SS: Debug> Debug for GpOrs<HCRS, ORS, SCRS, SS>

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

Formats the value using the given formatter.

impl<HCRS: Default, ORS: Default, SCRS: Default, SS: Default> Default for GpOrs<HCRS, ORS, SCRS, SS>

fn default() -> GpOrs<HCRS, ORS, SCRS, SS>

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>

impl<HCRS: PartialEq, ORS: PartialEq, SCRS: PartialEq, SS: PartialEq> PartialEq<GpOrs<HCRS, ORS, SCRS, SS>> for GpOrs<HCRS, ORS, SCRS, SS>

fn eq(&self, other: &GpOrs<HCRS, ORS, SCRS, SS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &GpOrs<HCRS, ORS, SCRS, SS>) -> bool

This method tests for !=.

impl<HCRS, ORS, SCRS, SS> StructuralPartialEq for GpOrs<HCRS, ORS, SCRS, SS>