Trait mop_blocks::prelude::SolutionDomain

pub trait SolutionDomain<S>: TraitCfg {
    fn new_rnd_solution<R>(
        &self, 
        vars_num: RangeInclusive<usize>, 
        rng: &mut R
    ) -> S
    where
        R: Rng;
    fn set_rnd_solution_domain<R>(&self, s: &mut S, idx: usize, rng: &mut R)
    where
        R: Rng;
}

A solution domain is a set/tuple of flattened and indexed values.

A domain creates and modifies solutions.

Required methods

fn new_rnd_solution<R>(&self, vars_num: RangeInclusive<usize>, rng: &mut R) -> S where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut S, idx: usize, rng: &mut R) where
    R: Rng, 

Loading content...

Implementations on Foreign Types

impl<S> SolutionDomain<S> for () where
    S: Default, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, _: &mut R) -> S where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, _: &mut S, _: usize, _: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<[T; 1]> for [RangeInclusive<T>; 1] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 1] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 1], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 1]>, VecArray<[usize; 1]>>> for DrMatrixVecArray<[RangeInclusive<T>; 1]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 1], [usize; 1]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 1], [usize; 1]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 1]>, VecArray<[usize; 1]>>> for [RangeInclusive<T>; 1] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 1], [usize; 1]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 1], [usize; 1]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 1]>>> for DrMatrixVecArray<[RangeInclusive<T>; 1]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 1]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 1]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 1]>> for VecArray<[RangeInclusive<T>; 1]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 1]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 1]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 2]> for [RangeInclusive<T>; 2] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 2] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 2], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 2]>, VecArray<[usize; 2]>>> for DrMatrixVecArray<[RangeInclusive<T>; 2]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 2], [usize; 2]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 2], [usize; 2]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 2]>, VecArray<[usize; 2]>>> for [RangeInclusive<T>; 2] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 2], [usize; 2]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 2], [usize; 2]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 2]>>> for DrMatrixVecArray<[RangeInclusive<T>; 2]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 2]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 2]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 2]>> for VecArray<[RangeInclusive<T>; 2]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 2]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 2]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 3]> for [RangeInclusive<T>; 3] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 3] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 3], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 3]>, VecArray<[usize; 3]>>> for DrMatrixVecArray<[RangeInclusive<T>; 3]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 3], [usize; 3]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 3], [usize; 3]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 3]>, VecArray<[usize; 3]>>> for [RangeInclusive<T>; 3] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 3], [usize; 3]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 3], [usize; 3]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 3]>>> for DrMatrixVecArray<[RangeInclusive<T>; 3]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 3]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 3]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 3]>> for VecArray<[RangeInclusive<T>; 3]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 3]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 3]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 4]> for [RangeInclusive<T>; 4] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 4] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 4], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 4]>, VecArray<[usize; 4]>>> for DrMatrixVecArray<[RangeInclusive<T>; 4]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 4], [usize; 4]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 4], [usize; 4]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 4]>, VecArray<[usize; 4]>>> for [RangeInclusive<T>; 4] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 4], [usize; 4]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 4], [usize; 4]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 4]>>> for DrMatrixVecArray<[RangeInclusive<T>; 4]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 4]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 4]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 4]>> for VecArray<[RangeInclusive<T>; 4]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 4]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 4]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 5]> for [RangeInclusive<T>; 5] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 5] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 5], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 5]>, VecArray<[usize; 5]>>> for DrMatrixVecArray<[RangeInclusive<T>; 5]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 5], [usize; 5]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 5], [usize; 5]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 5]>, VecArray<[usize; 5]>>> for [RangeInclusive<T>; 5] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 5], [usize; 5]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 5], [usize; 5]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 5]>>> for DrMatrixVecArray<[RangeInclusive<T>; 5]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 5]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 5]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 5]>> for VecArray<[RangeInclusive<T>; 5]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 5]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 5]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 6]> for [RangeInclusive<T>; 6] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 6] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 6], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 6]>, VecArray<[usize; 6]>>> for DrMatrixVecArray<[RangeInclusive<T>; 6]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 6], [usize; 6]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 6], [usize; 6]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 6]>, VecArray<[usize; 6]>>> for [RangeInclusive<T>; 6] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 6], [usize; 6]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 6], [usize; 6]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 6]>>> for DrMatrixVecArray<[RangeInclusive<T>; 6]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 6]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 6]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 6]>> for VecArray<[RangeInclusive<T>; 6]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 6]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 6]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 7]> for [RangeInclusive<T>; 7] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 7] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 7], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 7]>, VecArray<[usize; 7]>>> for DrMatrixVecArray<[RangeInclusive<T>; 7]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 7], [usize; 7]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 7], [usize; 7]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 7]>, VecArray<[usize; 7]>>> for [RangeInclusive<T>; 7] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 7], [usize; 7]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 7], [usize; 7]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 7]>>> for DrMatrixVecArray<[RangeInclusive<T>; 7]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 7]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 7]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 7]>> for VecArray<[RangeInclusive<T>; 7]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 7]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 7]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 8]> for [RangeInclusive<T>; 8] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 8] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 8], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 8]>, VecArray<[usize; 8]>>> for DrMatrixVecArray<[RangeInclusive<T>; 8]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 8], [usize; 8]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 8], [usize; 8]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 8]>, VecArray<[usize; 8]>>> for [RangeInclusive<T>; 8] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 8], [usize; 8]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 8], [usize; 8]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 8]>>> for DrMatrixVecArray<[RangeInclusive<T>; 8]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 8]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 8]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 8]>> for VecArray<[RangeInclusive<T>; 8]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 8]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 8]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 9]> for [RangeInclusive<T>; 9] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 9] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 9], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 9]>, VecArray<[usize; 9]>>> for DrMatrixVecArray<[RangeInclusive<T>; 9]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 9], [usize; 9]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 9], [usize; 9]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 9]>, VecArray<[usize; 9]>>> for [RangeInclusive<T>; 9] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 9], [usize; 9]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 9], [usize; 9]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 9]>>> for DrMatrixVecArray<[RangeInclusive<T>; 9]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 9]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 9]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 9]>> for VecArray<[RangeInclusive<T>; 9]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 9]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 9]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 10]> for [RangeInclusive<T>; 10] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 10] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 10], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 10]>, VecArray<[usize; 10]>>> for DrMatrixVecArray<[RangeInclusive<T>; 10]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 10], [usize; 10]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 10], [usize; 10]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 10]>, VecArray<[usize; 10]>>> for [RangeInclusive<T>; 10] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 10], [usize; 10]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 10], [usize; 10]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 10]>>> for DrMatrixVecArray<[RangeInclusive<T>; 10]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 10]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 10]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 10]>> for VecArray<[RangeInclusive<T>; 10]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 10]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 10]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 11]> for [RangeInclusive<T>; 11] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 11] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 11], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 11]>, VecArray<[usize; 11]>>> for DrMatrixVecArray<[RangeInclusive<T>; 11]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 11], [usize; 11]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 11], [usize; 11]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 11]>, VecArray<[usize; 11]>>> for [RangeInclusive<T>; 11] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 11], [usize; 11]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 11], [usize; 11]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 11]>>> for DrMatrixVecArray<[RangeInclusive<T>; 11]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 11]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 11]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 11]>> for VecArray<[RangeInclusive<T>; 11]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 11]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 11]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 12]> for [RangeInclusive<T>; 12] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 12] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 12], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 12]>, VecArray<[usize; 12]>>> for DrMatrixVecArray<[RangeInclusive<T>; 12]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 12], [usize; 12]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 12], [usize; 12]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 12]>, VecArray<[usize; 12]>>> for [RangeInclusive<T>; 12] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 12], [usize; 12]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 12], [usize; 12]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 12]>>> for DrMatrixVecArray<[RangeInclusive<T>; 12]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 12]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 12]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 12]>> for VecArray<[RangeInclusive<T>; 12]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 12]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 12]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 13]> for [RangeInclusive<T>; 13] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 13] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 13], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 13]>, VecArray<[usize; 13]>>> for DrMatrixVecArray<[RangeInclusive<T>; 13]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 13], [usize; 13]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 13], [usize; 13]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 13]>, VecArray<[usize; 13]>>> for [RangeInclusive<T>; 13] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 13], [usize; 13]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 13], [usize; 13]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 13]>>> for DrMatrixVecArray<[RangeInclusive<T>; 13]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 13]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 13]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 13]>> for VecArray<[RangeInclusive<T>; 13]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 13]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 13]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 14]> for [RangeInclusive<T>; 14] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 14] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 14], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 14]>, VecArray<[usize; 14]>>> for DrMatrixVecArray<[RangeInclusive<T>; 14]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 14], [usize; 14]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 14], [usize; 14]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 14]>, VecArray<[usize; 14]>>> for [RangeInclusive<T>; 14] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 14], [usize; 14]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 14], [usize; 14]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 14]>>> for DrMatrixVecArray<[RangeInclusive<T>; 14]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 14]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 14]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 14]>> for VecArray<[RangeInclusive<T>; 14]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 14]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 14]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 15]> for [RangeInclusive<T>; 15] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 15] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 15], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 15]>, VecArray<[usize; 15]>>> for DrMatrixVecArray<[RangeInclusive<T>; 15]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 15], [usize; 15]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 15], [usize; 15]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 15]>, VecArray<[usize; 15]>>> for [RangeInclusive<T>; 15] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 15], [usize; 15]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 15], [usize; 15]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 15]>>> for DrMatrixVecArray<[RangeInclusive<T>; 15]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 15]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 15]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 15]>> for VecArray<[RangeInclusive<T>; 15]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 15]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 15]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 16]> for [RangeInclusive<T>; 16] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 16] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 16], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 16]>, VecArray<[usize; 16]>>> for DrMatrixVecArray<[RangeInclusive<T>; 16]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 16], [usize; 16]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 16], [usize; 16]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 16]>, VecArray<[usize; 16]>>> for [RangeInclusive<T>; 16] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 16], [usize; 16]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 16], [usize; 16]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 16]>>> for DrMatrixVecArray<[RangeInclusive<T>; 16]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 16]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 16]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 16]>> for VecArray<[RangeInclusive<T>; 16]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 16]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 16]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 17]> for [RangeInclusive<T>; 17] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 17] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 17], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 17]>, VecArray<[usize; 17]>>> for DrMatrixVecArray<[RangeInclusive<T>; 17]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 17], [usize; 17]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 17], [usize; 17]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 17]>, VecArray<[usize; 17]>>> for [RangeInclusive<T>; 17] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 17], [usize; 17]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 17], [usize; 17]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 17]>>> for DrMatrixVecArray<[RangeInclusive<T>; 17]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 17]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 17]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 17]>> for VecArray<[RangeInclusive<T>; 17]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 17]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 17]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 18]> for [RangeInclusive<T>; 18] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 18] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 18], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 18]>, VecArray<[usize; 18]>>> for DrMatrixVecArray<[RangeInclusive<T>; 18]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 18], [usize; 18]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 18], [usize; 18]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 18]>, VecArray<[usize; 18]>>> for [RangeInclusive<T>; 18] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 18], [usize; 18]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 18], [usize; 18]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 18]>>> for DrMatrixVecArray<[RangeInclusive<T>; 18]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 18]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 18]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 18]>> for VecArray<[RangeInclusive<T>; 18]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 18]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 18]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 19]> for [RangeInclusive<T>; 19] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 19] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 19], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 19]>, VecArray<[usize; 19]>>> for DrMatrixVecArray<[RangeInclusive<T>; 19]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 19], [usize; 19]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 19], [usize; 19]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 19]>, VecArray<[usize; 19]>>> for [RangeInclusive<T>; 19] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 19], [usize; 19]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 19], [usize; 19]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 19]>>> for DrMatrixVecArray<[RangeInclusive<T>; 19]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 19]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 19]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 19]>> for VecArray<[RangeInclusive<T>; 19]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 19]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 19]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 20]> for [RangeInclusive<T>; 20] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 20] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 20], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 20]>, VecArray<[usize; 20]>>> for DrMatrixVecArray<[RangeInclusive<T>; 20]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 20], [usize; 20]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 20], [usize; 20]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 20]>, VecArray<[usize; 20]>>> for [RangeInclusive<T>; 20] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 20], [usize; 20]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 20], [usize; 20]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 20]>>> for DrMatrixVecArray<[RangeInclusive<T>; 20]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 20]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 20]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 20]>> for VecArray<[RangeInclusive<T>; 20]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 20]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 20]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 21]> for [RangeInclusive<T>; 21] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 21] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 21], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 21]>, VecArray<[usize; 21]>>> for DrMatrixVecArray<[RangeInclusive<T>; 21]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 21], [usize; 21]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 21], [usize; 21]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 21]>, VecArray<[usize; 21]>>> for [RangeInclusive<T>; 21] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 21], [usize; 21]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 21], [usize; 21]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 21]>>> for DrMatrixVecArray<[RangeInclusive<T>; 21]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 21]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 21]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 21]>> for VecArray<[RangeInclusive<T>; 21]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 21]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 21]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 22]> for [RangeInclusive<T>; 22] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 22] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 22], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 22]>, VecArray<[usize; 22]>>> for DrMatrixVecArray<[RangeInclusive<T>; 22]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 22], [usize; 22]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 22], [usize; 22]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 22]>, VecArray<[usize; 22]>>> for [RangeInclusive<T>; 22] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 22], [usize; 22]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 22], [usize; 22]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 22]>>> for DrMatrixVecArray<[RangeInclusive<T>; 22]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 22]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 22]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 22]>> for VecArray<[RangeInclusive<T>; 22]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 22]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 22]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 23]> for [RangeInclusive<T>; 23] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 23] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 23], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 23]>, VecArray<[usize; 23]>>> for DrMatrixVecArray<[RangeInclusive<T>; 23]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 23], [usize; 23]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 23], [usize; 23]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 23]>, VecArray<[usize; 23]>>> for [RangeInclusive<T>; 23] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 23], [usize; 23]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 23], [usize; 23]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 23]>>> for DrMatrixVecArray<[RangeInclusive<T>; 23]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 23]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 23]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 23]>> for VecArray<[RangeInclusive<T>; 23]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 23]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 23]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 24]> for [RangeInclusive<T>; 24] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 24] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 24], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 24]>, VecArray<[usize; 24]>>> for DrMatrixVecArray<[RangeInclusive<T>; 24]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 24], [usize; 24]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 24], [usize; 24]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 24]>, VecArray<[usize; 24]>>> for [RangeInclusive<T>; 24] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 24], [usize; 24]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 24], [usize; 24]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 24]>>> for DrMatrixVecArray<[RangeInclusive<T>; 24]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 24]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 24]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 24]>> for VecArray<[RangeInclusive<T>; 24]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 24]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 24]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 25]> for [RangeInclusive<T>; 25] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 25] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 25], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 25]>, VecArray<[usize; 25]>>> for DrMatrixVecArray<[RangeInclusive<T>; 25]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 25], [usize; 25]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 25], [usize; 25]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 25]>, VecArray<[usize; 25]>>> for [RangeInclusive<T>; 25] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 25], [usize; 25]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 25], [usize; 25]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 25]>>> for DrMatrixVecArray<[RangeInclusive<T>; 25]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 25]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 25]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 25]>> for VecArray<[RangeInclusive<T>; 25]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 25]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 25]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 26]> for [RangeInclusive<T>; 26] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 26] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 26], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 26]>, VecArray<[usize; 26]>>> for DrMatrixVecArray<[RangeInclusive<T>; 26]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 26], [usize; 26]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 26], [usize; 26]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 26]>, VecArray<[usize; 26]>>> for [RangeInclusive<T>; 26] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 26], [usize; 26]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 26], [usize; 26]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 26]>>> for DrMatrixVecArray<[RangeInclusive<T>; 26]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 26]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 26]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 26]>> for VecArray<[RangeInclusive<T>; 26]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 26]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 26]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 27]> for [RangeInclusive<T>; 27] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 27] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 27], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 27]>, VecArray<[usize; 27]>>> for DrMatrixVecArray<[RangeInclusive<T>; 27]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 27], [usize; 27]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 27], [usize; 27]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 27]>, VecArray<[usize; 27]>>> for [RangeInclusive<T>; 27] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 27], [usize; 27]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 27], [usize; 27]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 27]>>> for DrMatrixVecArray<[RangeInclusive<T>; 27]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 27]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 27]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 27]>> for VecArray<[RangeInclusive<T>; 27]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 27]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 27]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 28]> for [RangeInclusive<T>; 28] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 28] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 28], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 28]>, VecArray<[usize; 28]>>> for DrMatrixVecArray<[RangeInclusive<T>; 28]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 28], [usize; 28]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 28], [usize; 28]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 28]>, VecArray<[usize; 28]>>> for [RangeInclusive<T>; 28] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 28], [usize; 28]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 28], [usize; 28]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 28]>>> for DrMatrixVecArray<[RangeInclusive<T>; 28]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 28]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 28]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 28]>> for VecArray<[RangeInclusive<T>; 28]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 28]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 28]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 29]> for [RangeInclusive<T>; 29] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 29] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 29], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 29]>, VecArray<[usize; 29]>>> for DrMatrixVecArray<[RangeInclusive<T>; 29]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 29], [usize; 29]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 29], [usize; 29]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 29]>, VecArray<[usize; 29]>>> for [RangeInclusive<T>; 29] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 29], [usize; 29]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 29], [usize; 29]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 29]>>> for DrMatrixVecArray<[RangeInclusive<T>; 29]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 29]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 29]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 29]>> for VecArray<[RangeInclusive<T>; 29]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 29]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 29]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 30]> for [RangeInclusive<T>; 30] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 30] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 30], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 30]>, VecArray<[usize; 30]>>> for DrMatrixVecArray<[RangeInclusive<T>; 30]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 30], [usize; 30]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 30], [usize; 30]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 30]>, VecArray<[usize; 30]>>> for [RangeInclusive<T>; 30] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 30], [usize; 30]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 30], [usize; 30]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 30]>>> for DrMatrixVecArray<[RangeInclusive<T>; 30]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 30]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 30]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 30]>> for VecArray<[RangeInclusive<T>; 30]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 30]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 30]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 31]> for [RangeInclusive<T>; 31] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 31] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 31], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 31]>, VecArray<[usize; 31]>>> for DrMatrixVecArray<[RangeInclusive<T>; 31]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 31], [usize; 31]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 31], [usize; 31]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 31]>, VecArray<[usize; 31]>>> for [RangeInclusive<T>; 31] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 31], [usize; 31]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 31], [usize; 31]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 31]>>> for DrMatrixVecArray<[RangeInclusive<T>; 31]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 31]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 31]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 31]>> for VecArray<[RangeInclusive<T>; 31]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 31]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 31]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 32]> for [RangeInclusive<T>; 32] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 32] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 32], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 32]>, VecArray<[usize; 32]>>> for DrMatrixVecArray<[RangeInclusive<T>; 32]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 32], [usize; 32]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 32], [usize; 32]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 32]>, VecArray<[usize; 32]>>> for [RangeInclusive<T>; 32] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 32], [usize; 32]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 32], [usize; 32]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 32]>>> for DrMatrixVecArray<[RangeInclusive<T>; 32]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 32]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 32]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 32]>> for VecArray<[RangeInclusive<T>; 32]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 32]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 32]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 64]> for [RangeInclusive<T>; 64] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 64] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 64], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 64]>, VecArray<[usize; 64]>>> for DrMatrixVecArray<[RangeInclusive<T>; 64]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 64], [usize; 64]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 64], [usize; 64]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 64]>, VecArray<[usize; 64]>>> for [RangeInclusive<T>; 64] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 64], [usize; 64]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 64], [usize; 64]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 64]>>> for DrMatrixVecArray<[RangeInclusive<T>; 64]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 64]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 64]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 64]>> for VecArray<[RangeInclusive<T>; 64]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 64]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 64]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 128]> for [RangeInclusive<T>; 128] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 128] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 128], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 128]>, VecArray<[usize; 128]>>> for DrMatrixVecArray<[RangeInclusive<T>; 128]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 128], [usize; 128]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 128], [usize; 128]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 128]>, VecArray<[usize; 128]>>> for [RangeInclusive<T>; 128] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 128], [usize; 128]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 128], [usize; 128]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 128]>>> for DrMatrixVecArray<[RangeInclusive<T>; 128]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 128]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 128]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 128]>> for VecArray<[RangeInclusive<T>; 128]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 128]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 128]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 256]> for [RangeInclusive<T>; 256] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 256] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 256], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 256]>, VecArray<[usize; 256]>>> for DrMatrixVecArray<[RangeInclusive<T>; 256]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 256], [usize; 256]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 256], [usize; 256]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 256]>, VecArray<[usize; 256]>>> for [RangeInclusive<T>; 256] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 256], [usize; 256]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 256], [usize; 256]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 256]>>> for DrMatrixVecArray<[RangeInclusive<T>; 256]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 256]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 256]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 256]>> for VecArray<[RangeInclusive<T>; 256]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 256]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 256]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 512]> for [RangeInclusive<T>; 512] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(&self, _: RangeInclusive<usize>, rng: &mut R) -> [T; 512] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 512], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 512]>, VecArray<[usize; 512]>>> for DrMatrixVecArray<[RangeInclusive<T>; 512]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 512], [usize; 512]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 512], [usize; 512]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 512]>, VecArray<[usize; 512]>>> for [RangeInclusive<T>; 512] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 512], [usize; 512]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 512], [usize; 512]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 512]>>> for DrMatrixVecArray<[RangeInclusive<T>; 512]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 512]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 512]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 512]>> for VecArray<[RangeInclusive<T>; 512]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 512]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 512]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 1024]> for [RangeInclusive<T>; 1024] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 1024] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 1024], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 1024]>, VecArray<[usize; 1024]>>> for DrMatrixVecArray<[RangeInclusive<T>; 1024]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 1024], [usize; 1024]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 1024], [usize; 1024]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 1024]>, VecArray<[usize; 1024]>>> for [RangeInclusive<T>; 1024] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 1024], [usize; 1024]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 1024], [usize; 1024]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 1024]>>> for DrMatrixVecArray<[RangeInclusive<T>; 1024]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 1024]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 1024]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 1024]>> for VecArray<[RangeInclusive<T>; 1024]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 1024]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 1024]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 2048]> for [RangeInclusive<T>; 2048] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 2048] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 2048], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 2048]>, VecArray<[usize; 2048]>>> for DrMatrixVecArray<[RangeInclusive<T>; 2048]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 2048], [usize; 2048]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 2048], [usize; 2048]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 2048]>, VecArray<[usize; 2048]>>> for [RangeInclusive<T>; 2048] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 2048], [usize; 2048]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 2048], [usize; 2048]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 2048]>>> for DrMatrixVecArray<[RangeInclusive<T>; 2048]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 2048]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 2048]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 2048]>> for VecArray<[RangeInclusive<T>; 2048]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 2048]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 2048]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 4096]> for [RangeInclusive<T>; 4096] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 4096] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 4096], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 4096]>, VecArray<[usize; 4096]>>> for DrMatrixVecArray<[RangeInclusive<T>; 4096]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 4096], [usize; 4096]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 4096], [usize; 4096]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 4096]>, VecArray<[usize; 4096]>>> for [RangeInclusive<T>; 4096] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 4096], [usize; 4096]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 4096], [usize; 4096]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 4096]>>> for DrMatrixVecArray<[RangeInclusive<T>; 4096]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 4096]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 4096]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 4096]>> for VecArray<[RangeInclusive<T>; 4096]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 4096]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 4096]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 8192]> for [RangeInclusive<T>; 8192] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 8192] where
    R: Rng, 

fn set_rnd_solution_domain<R>(&self, s: &mut [T; 8192], idx: usize, rng: &mut R) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 8192]>, VecArray<[usize; 8192]>>> for DrMatrixVecArray<[RangeInclusive<T>; 8192]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 8192], [usize; 8192]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 8192], [usize; 8192]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 8192]>, VecArray<[usize; 8192]>>> for [RangeInclusive<T>; 8192] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 8192], [usize; 8192]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 8192], [usize; 8192]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 8192]>>> for DrMatrixVecArray<[RangeInclusive<T>; 8192]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 8192]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 8192]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 8192]>> for VecArray<[RangeInclusive<T>; 8192]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 8192]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 8192]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 16384]> for [RangeInclusive<T>; 16384] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 16384] where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut [T; 16384],
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 16384]>, VecArray<[usize; 16384]>>> for DrMatrixVecArray<[RangeInclusive<T>; 16384]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 16384], [usize; 16384]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 16384], [usize; 16384]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 16384]>, VecArray<[usize; 16384]>>> for [RangeInclusive<T>; 16384] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 16384], [usize; 16384]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 16384], [usize; 16384]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 16384]>>> for DrMatrixVecArray<[RangeInclusive<T>; 16384]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 16384]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 16384]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 16384]>> for VecArray<[RangeInclusive<T>; 16384]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 16384]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 16384]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 32768]> for [RangeInclusive<T>; 32768] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 32768] where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut [T; 32768],
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 32768]>, VecArray<[usize; 32768]>>> for DrMatrixVecArray<[RangeInclusive<T>; 32768]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 32768], [usize; 32768]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 32768], [usize; 32768]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 32768]>, VecArray<[usize; 32768]>>> for [RangeInclusive<T>; 32768] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 32768], [usize; 32768]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 32768], [usize; 32768]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 32768]>>> for DrMatrixVecArray<[RangeInclusive<T>; 32768]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 32768]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 32768]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 32768]>> for VecArray<[RangeInclusive<T>; 32768]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 32768]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 32768]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<[T; 65536]> for [RangeInclusive<T>; 65536] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> [T; 65536] where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut [T; 65536],
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<CsrMatrix<VecArray<[T; 65536]>, VecArray<[usize; 65536]>>> for DrMatrixVecArray<[RangeInclusive<T>; 65536]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CsrMatrixVecArray<[T; 65536], [usize; 65536]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CsrMatrixVecArray<[T; 65536], [usize; 65536]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<Css<VecArray<[T; 65536]>, VecArray<[usize; 65536]>>> for [RangeInclusive<T>; 65536] where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> CssVecArray<[T; 65536], [usize; 65536]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut CssVecArray<[T; 65536], [usize; 65536]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<DrMatrix<VecArray<[T; 65536]>>> for DrMatrixVecArray<[RangeInclusive<T>; 65536]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    _: RangeInclusive<usize>,
    rng: &mut R
) -> DrMatrixVecArray<[T; 65536]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut DrMatrixVecArray<[T; 65536]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

impl<T> SolutionDomain<VecArray<[T; 65536]>> for VecArray<[RangeInclusive<T>; 65536]> where
    T: Copy + Debug + SampleUniform + TraitCfg, 

fn new_rnd_solution<R>(
    &self,
    vars_num: RangeInclusive<usize>,
    rng: &mut R
) -> VecArray<[T; 65536]> where
    R: Rng, 

fn set_rnd_solution_domain<R>(
    &self,
    s: &mut VecArray<[T; 65536]>,
    idx: usize,
    rng: &mut R
) where
    R: Rng, 

Loading content...

Implementors

Loading content...