Struct Population 

pub struct Population<B: Backend, K> { /* private fields */ }

Population stored on a Burn backend device.

The concrete tensor type depends on the genome kind K. Most consumers interact with Population<B, Real> via tensor, but strategies parameterized on the kind can keep the K generic and reach for the right tensor flavor through the inherent impls below.

Invariant: for every Population<B, K> produced by the public constructors, exactly one of tensor_real / tensor_int is Some, determined by K. Real populates tensor_real; Binary, Integer, and Permutation populate tensor_int. The inherent tensor(&self) accessors .expect() on the matching field because the constructor contract pins the invariant — a mismatch would be a bug in this module.

Implementations

impl<B: Backend, K> Population<B, K>

pub fn pop_size(&self) -> usize

Returns the number of individuals (rows) in the population.

This value equals tensor.dims()[0] for any population produced by the public constructors.

pub fn genome_dim(&self) -> usize

Returns the genome dimensionality (number of genes, i.e. columns).

This value equals tensor.dims()[1] for any population produced by the public constructors.

impl<B: Backend> Population<B, Real>

pub fn new_real(tensor: Tensor<B, 2>) -> Self

Constructs a real-valued population from a Tensor<B, 2>.

Shape is read from tensor.dims() at construction time; subsequent calls to pop_size and genome_dim reflect those dimensions.

Examples

use burn::backend::Flex;
use burn::tensor::{Tensor, TensorData};
use rlevo_evolution::genome::Real;
use rlevo_evolution::population::Population;

let device = Default::default();
let data = TensorData::new(vec![1.0f32, 2.0, 3.0, 4.0], [2, 2]);
let pop = Population::<Flex, Real>::new_real(
    Tensor::from_data(data, &device),
);
assert_eq!(pop.pop_size(), 2);
assert_eq!(pop.genome_dim(), 2);

Panics

Panics if tensor is not rank 2.

pub fn tensor(&self) -> &Tensor<B, 2>

Borrows the backing real-valued tensor.

The returned tensor has shape [pop_size, genome_dim]. Use this to pass the population to fitness functions or operator kernels without giving up ownership.

Panics

Never panics in practice: a real-valued population always holds a real tensor by construction.

pub fn into_tensor(self) -> Tensor<B, 2>

Consumes the wrapper and returns the owned tensor.

Prefer this over tensor when handing the population off to a strategy or operator that needs ownership (e.g. to avoid a clone on the hot path).

Panics

Never panics in practice: a real-valued population always holds a real tensor by construction.

impl<B: Backend> Population<B, Binary>

pub fn new_binary(tensor: Tensor<B, 2, Int>) -> Self

Constructs a binary population from a Tensor<B, 2, Int>.

Each element is expected to be 0 or 1; the constructor does not validate element values. Shape is read from tensor.dims().

Examples

use burn::backend::Flex;
use burn::tensor::{Int, Tensor, TensorData};
use rlevo_evolution::genome::Binary;
use rlevo_evolution::population::Population;

let device = Default::default();
// 3 individuals, each with a 4-bit binary genome.
let data = TensorData::new(vec![0i64, 1, 0, 1,
                                1, 0, 1, 0,
                                0, 0, 1, 1], [3, 4]);
let pop = Population::<Flex, Binary>::new_binary(
    Tensor::from_data(data, &device),
);
assert_eq!(pop.pop_size(), 3);
assert_eq!(pop.genome_dim(), 4);

Panics

Panics if tensor is not rank 2.

pub fn tensor(&self) -> &Tensor<B, 2, Int>

Borrows the backing integer tensor holding 0/1 values.

The returned tensor has shape [pop_size, genome_dim] and element type Int. Callers performing crossover or mutation should work directly with this tensor.

Panics

Never panics in practice: a binary population always holds an integer tensor by construction.

impl<B: Backend> Population<B, Integer>

pub fn new_integer(tensor: Tensor<B, 2, Int>) -> Self

Constructs an integer population from a Tensor<B, 2, Int>.

Elements represent non-negative integer indices (e.g. node indices in CGP, symbol indices in integer-coded GA). The constructor does not validate element bounds. Shape is read from tensor.dims().

Examples

use burn::backend::Flex;
use burn::tensor::{Int, Tensor, TensorData};
use rlevo_evolution::genome::Integer;
use rlevo_evolution::population::Population;

let device = Default::default();
// 2 individuals, each with a 5-gene integer-valued genome.
let data = TensorData::new(vec![0i64, 3, 1, 4, 2,
                                2, 0, 4, 1, 3], [2, 5]);
let pop = Population::<Flex, Integer>::new_integer(
    Tensor::from_data(data, &device),
);
assert_eq!(pop.pop_size(), 2);
assert_eq!(pop.genome_dim(), 5);

Panics

Panics if tensor is not rank 2.

pub fn tensor(&self) -> &Tensor<B, 2, Int>

Borrows the backing integer tensor.

The returned tensor has shape [pop_size, genome_dim] and element type Int. Element values are non-negative indices whose domain is determined by the problem (e.g. 0..n_nodes for CGP).

Panics

Never panics in practice: an integer population always holds an integer tensor by construction.

Trait Implementations

impl<B: Clone + Backend, K: Clone> Clone for Population<B, K>

fn clone(&self) -> Population<B, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend, K: Debug> Debug for Population<B, K>

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

Formats the value using the given formatter.