Struct FloatGene 

pub struct FloatGene<F>
where
    F: Float,
{ /* private fields */ }

A Gene that represents a floating point number. The allele is the in the case of the FloatGene is of type F - which is a floating point type. The min and max values default to F::MIN and F::MAX respectively. During evolution, the value_range is used to generate new allele values, while the bounds are used to ensure that the allele remains within a valid range. If no bounds are provided, they default to the same values as value_range.

Example

use radiate_core::*;

// Create a new FloatGene with a min value of 0 and a max value of 1 meaning the
// allele will be a random number between 0 and 1.
// The upper_bound and lower_bound are set to 0 and 1 respectively.
let gene = FloatGene::from(0_f32..1_f32);

// Create a new FloatGene with a min of 0 and a max of 1 and set the upper_bound
// and lower_bound to 0 and 100 respectively.
let gene = FloatGene::from((0_f32..1_f32, 0_f32..100_f32));

Implementations

impl<F> FloatGene<F>

where F: Float,

pub fn new(allele: F, value_range: Range<F>, bounds: Range<F>) -> FloatGene<F>

Creates a new FloatGene with the given allele, value_range, and bounds.

Trait Implementations

impl<F> Add for FloatGene<F>

where F: Float,

type Output = FloatGene<F>

The resulting type after applying the + operator.

fn add(self, other: FloatGene<F>) -> FloatGene<F>

Performs the + operation.

impl<F> ArithmeticGene for FloatGene<F>

where F: Float,

fn mean(&self, other: &FloatGene<F>) -> FloatGene<F>

impl<F> BoundedGene for FloatGene<F>

where F: Float,

fn min(&self) -> &<FloatGene<F> as Gene>::Allele

fn max(&self) -> &<FloatGene<F> as Gene>::Allele

fn bounds( &self, ) -> (&<FloatGene<F> as Gene>::Allele, &<FloatGene<F> as Gene>::Allele)

impl<F> Clone for FloatGene<F>

where F: Clone + Float,

fn clone(&self) -> FloatGene<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Debug for FloatGene<F>

where F: Debug + Float,

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

Formats the value using the given formatter.

impl<F> Default for FloatGene<F>

where F: Float,

fn default() -> FloatGene<F>

Returns the “default value” for a type.

impl<F> Display for FloatGene<F>

where F: Float,

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

Formats the value using the given formatter.

impl<F> Div for FloatGene<F>

where F: Float,

type Output = FloatGene<F>

The resulting type after applying the / operator.

fn div(self, other: FloatGene<F>) -> FloatGene<F>

Performs the / operation.

impl<F> From<(Range<F>, Range<F>)> for FloatGene<F>

where F: Float,

fn from(_: (Range<F>, Range<F>)) -> FloatGene<F>

Converts to this type from the input type.

impl<F> From<F> for FloatGene<F>

where F: Float,

fn from(allele: F) -> FloatGene<F>

Converts to this type from the input type.

impl<F> From<FloatGene<F>> for FloatChromosome<F>

where F: Float,

fn from(gene: FloatGene<F>) -> FloatChromosome<F>

Converts to this type from the input type.

impl<F> From<Range<F>> for FloatGene<F>

where F: Float,

fn from(range: Range<F>) -> FloatGene<F>

Converts to this type from the input type.

impl<F> FromIterator<FloatGene<F>> for FloatChromosome<F>

where F: Float,

fn from_iter<I>(iter: I) -> FloatChromosome<F>

where I: IntoIterator<Item = FloatGene<F>>,

Creates a value from an iterator.

impl<F> Gene for FloatGene<F>

where F: Float,

type Allele = F

fn allele(&self) -> &F

Get the allele of the Gene. This is the value that the Gene represents or “expresses”.

fn allele_mut(&mut self) -> &mut F

Get a mutable reference to the allele of the Gene.

fn new_instance(&self) -> FloatGene<F>

Create a new instance of the Gene.

fn with_allele(&self, allele: &F) -> FloatGene<F>

Create a new Gene with the given allele.

impl<F> Mul for FloatGene<F>

where F: Float,

type Output = FloatGene<F>

The resulting type after applying the * operator.

fn mul(self, other: FloatGene<F>) -> FloatGene<F>

Performs the * operation.

impl<F> PartialEq for FloatGene<F>

where F: PartialEq + Float,

fn eq(&self, other: &FloatGene<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> StructuralPartialEq for FloatGene<F>

where F: PartialEq + Float,

impl<F> Sub for FloatGene<F>

where F: Float,

type Output = FloatGene<F>

The resulting type after applying the - operator.

fn sub(self, other: FloatGene<F>) -> FloatGene<F>

Performs the - operation.

impl<F> Valid for FloatGene<F>

where F: Float,

Implement the Valid trait for the FloatGene.

The is_valid method checks if the allele of the FloatGene is between the min and max values. The GeneticEngine will check the validity of the Chromosome and Phenotype and remove any invalid individuals from the population, replacing them with new individuals at the given generation.

fn is_valid(&self) -> bool