Satisfy clippy

Author: Ploppz

src/nn/gene.rs

@@ -57,11 +57,11 @@ impl Gene {
         is_bias: bool,
     ) -> Gene {
         Gene {
-            in_neuron_id: in_neuron_id,
-            out_neuron_id: out_neuron_id,
-            weight: weight,
-            enabled: enabled,
-            is_bias: is_bias,
+            in_neuron_id,
+            out_neuron_id,
+            weight,
+            enabled,
+            is_bias,
         }
     }
     /// Generate a weight

src/nn/mod.rs

@@ -57,7 +57,7 @@ impl Genome for NeuralNetwork {
 
         // average weight differences of matching genes
         let w1 = matching_genes.iter().fold(0.0, |acc, &m_gene| {
-            acc + (m_gene.weight - &other.genes[other.genes.binary_search(m_gene).unwrap()].weight)
+            acc + (m_gene.weight - other.genes[other.genes.binary_search(m_gene).unwrap()].weight)
                 .abs()
         });
 
@@ -121,7 +121,7 @@ impl NeuralNetwork {
         let tau = vec![1.0; neurons_len];
         let theta = self.get_bias();
 
-        let mut i = sensors.clone();
+        let mut i = sensors;
 
         if neurons_len < sensors_len {
             i.truncate(neurons_len);
@@ -144,9 +144,9 @@ impl NeuralNetwork {
         if sensors_len < neurons_len {
             let outputs_activations = activations.split_at(sensors_len).1.to_vec();
 
-            for n in 0..cmp::min(outputs_activations.len(), outputs.len()) {
-                outputs[n] = outputs_activations[n];
-            }
+            let max_idx = cmp::min(outputs_activations.len(), outputs.len());
+            outputs[..max_idx]
+                .clone_from_slice(&outputs_activations[..max_idx])
         }
     }
 
@@ -204,7 +204,7 @@ impl NeuralNetwork {
             if self.last_neuron_id == 0 {
                 vec![0, 0]
             } else {
-                (0..self.last_neuron_id + 1).choose_multiple(&mut rng, 2)
+                (0..=self.last_neuron_id).choose_multiple(&mut rng, 2)
             }
         };
         self.add_connection(neuron_ids_to_connect[0], neuron_ids_to_connect[1]);

src/population.rs

@@ -53,7 +53,7 @@ impl<G: Genome> Population<G> {
         self.generate_offspring();
     }
     /// TODO
-    pub fn evaluate_in(&mut self, environment: &mut Environment<G>) {
+    pub fn evaluate_in(&mut self, environment: &mut dyn Environment<G>) {
         let champion = SpeciesEvaluator::new(environment).evaluate(&mut self.species);
 
         if self.champion_fitness >= champion.fitness {
@@ -135,7 +135,7 @@ impl<G: Genome> Population<G> {
         }
 
         for specie in &self.species {
-            if result.len() < 1 {
+            if result.is_empty() {
                 result.push(specie.clone())
             } else if result.len() < 2 {
                 if result[0].calculate_champion_fitness() < specie.calculate_champion_fitness() {
@@ -176,8 +176,8 @@ impl<G: Genome> Population<G> {
                     new_specie = Some(specie);
                 }
             };
-            if new_specie.is_some() {
-                self.species.push(new_specie.unwrap());
+            if let Some(new_specie) = new_specie {
+                self.species.push(new_specie);
             }
         }
     }

src/species_evaluator.rs

@@ -7,15 +7,15 @@ use std::sync::mpsc::{Receiver, Sender};
 /// Calculate fitness and champions for a species
 pub struct SpeciesEvaluator<'a, G> {
     threads: usize,
-    environment: &'a mut Environment<G>,
+    environment: &'a mut dyn Environment<G>,
 }
 
 impl<'a, G: Genome + Send> SpeciesEvaluator<'a, G> {
     /// Take an environment that will test organisms.
-    pub fn new(environment: &mut Environment<G>) -> SpeciesEvaluator<G> {
+    pub fn new(environment: &mut dyn Environment<G>) -> SpeciesEvaluator<G> {
         SpeciesEvaluator {
             threads: num_cpus::get(),
-            environment: environment,
+            environment,
         }
     }
 
@@ -64,7 +64,7 @@ impl<'a, G: Genome + Send> SpeciesEvaluator<'a, G> {
             match organisms.split_at_mut(organisms_by_thread) {
                 (thread_organisms, remaining_organisms) => {
                     self.evaluate_organisms(thread_organisms, tx.clone(), scope);
-                    if remaining_organisms.len() > 0 {
+                    if !remaining_organisms.is_empty() {
                         return self.dispatch_organisms(
                             remaining_organisms,
                             organisms_by_thread,