1 files changed, 17 insertions(+), 9 deletions(-)

M codes/eoa_lib/src/constraints.rs

@@ 1,5 1,6 @@
 use std::{collections::VecDeque, convert::Infallible, error::Error};
 
+use std::fmt::Debug;
 use rand::{Rng, RngCore};
 use thiserror::Error;
 


@@ 229,6 230,7 @@ pub struct ConstrainedEvaluation<const CONSTRAINTS: usize, TOut> {
     fitness: TOut,
     constraints: [TOut; CONSTRAINTS],
     weighted_sum: TOut,
+    constr_weighted_sum: TOut,
     is_feasible: bool,
 }
 


@@ 251,7 253,7 @@ pub struct ConstrainedEvalFitness<'a,
 
 impl <'a,
       const CONSTRAINTS: usize,
-      TOut: std::ops::Mul<Output = TOut> + std::ops::AddAssign + Copy + Default,
+      TOut: std::ops::Mul<Output = TOut> + std::ops::AddAssign + std::ops::Add<Output = TOut> + Copy + Default + PartialOrd + Debug,
       TIn,
       TFitness: FitnessFunction<In = TIn, Out = TOut>,
       TConstraint: ConstraintFunction<Chromosome = TIn, Out = TOut>>


@@ 266,7 268,7 @@ impl <'a,
             Err(err) =>
                 return Err(ConstrainedFitnessErr::FitnessErr(err))
         };
-        let mut weighted_sum = fit;
+        let mut constr_weighted_sum = Default::default();
         let mut constraints = [fit; CONSTRAINTS];
         let mut is_feasible = true;
 


@@ 278,20 280,24 @@ impl <'a,
             };
             constraints[i] = constraint_eval;
 
-            weighted_sum += match constraint.is_feasible(inp) {
-                Ok(true) => weight.clone() * constraint_eval,
+            constr_weighted_sum += match constraint.is_feasible(inp) {
                 Ok(false) => {
                     is_feasible = false;
+                    weight.clone() * constraint_eval
+                },
+                Ok(true) => {
                     Default::default()
                 },
                 Err(err) => return Err(ConstrainedFitnessErr::ConstraintErr(err))
             };
         }
 
+        assert!(constr_weighted_sum >= Default::default());
         Ok(ConstrainedEvaluation {
             fitness: fit,
             constraints,
-            weighted_sum,
+            constr_weighted_sum,
+            weighted_sum: fit + constr_weighted_sum,
             is_feasible
         })
     }


@@ 317,7 323,7 @@ fn stochastic_ranking_sort<const CONSTRAINTS: usize, TIn, TOut: PartialOrd + Def
                     indices.swap(j, j + 1);
                 }
             } else {
-                if current_evaluation.weighted_sum > next_evaluation.weighted_sum {
+                if current_evaluation.constr_weighted_sum > next_evaluation.constr_weighted_sum {
                     indices.swap(j, j + 1);
                 }
             }


@@ 339,7 345,7 @@ const MINIMIZING_OPERATOR: MinimizingOperator = MinimizingOperator;
 impl<'a,
      const CONSTRAINTS: usize,
      TChromosome,
-     TResult: PartialOrd + Default,
+     TResult: PartialOrd + Default + Clone + Debug,
      TSelection: Selection<(), usize>,
      TBetterThan: BetterThanOperator<TResult>>
     Selection<TChromosome, ConstrainedEvaluation<CONSTRAINTS, TResult>> for StochasticRankingSelection<'a, TSelection, TBetterThan> {


@@ 353,6 359,8 @@ impl<'a,
             evaluations.population.as_slice(),
             self.N, self.p, self.better_than, rng
         );
+        // println!("{:?}", sorted_indices.iter().map(|&x| evaluations.population[x].evaluation.weighted_sum.clone()).collect::<Vec<_>>());
+        // println!("{:?}", sorted_indices.iter().map(|&x| evaluations.population[x].evaluation.constr_weighted_sum.clone()).collect::<Vec<_>>());
         let mut rankings = vec![EvaluatedChromosome {
             chromosome: (),
             evaluation: 0


@@ 378,7 386,7 @@ impl<'a,
 
 pub fn stochastic_ranking_evolution_algorithm
     <TChromosome: Clone,
-     TResult: PartialOrd + std::ops::Mul<Output = TResult> + std::ops::AddAssign + Copy + Default,
+     TResult: PartialOrd + std::ops::Mul<Output = TResult> + std::ops::AddAssign + std::ops::Add<Output = TResult> + Copy + Default + Debug,
      const DParents: usize,
      const CONSTRAINTS: usize,
      TFitness: FitnessFunction<In = TChromosome, Out = TResult>,


@@ 448,7 456,7 @@ pub fn stochastic_ranking_evolution_algorithm
         |iteration, stats, population, fitness, selection, pairing, crossover, perturbation, replacement| {
             let feasible_fraction = population.population
                 .iter()
-                .map(|x| x.evaluation.is_feasible)
+                .filter(|x| x.evaluation.is_feasible)
                 .count() as f64 / population.population.len() as f64;
 
             feasible_fractions.push(feasible_fraction);