Struct Population 

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

Population stored on a Burn backend device.

The concrete tensor type depends on the genome kind K, chosen at compile time through TensorGenome::Tensor: Real is backed by Tensor<B, 2>, Binary and Integer by Tensor<B, 2, Int>. Because the storage type is a function of K, there is a single tensor field and no run-time tag — a population can never hold the wrong tensor flavour for its kind, so the tensor accessor is total (it cannot fail).

The K: TensorGenome bound is what keeps this honest: kinds without a rectangular tensor form (e.g. Tree) do not implement TensorGenome, so Population<B, Tree> does not type-check.

Implementations

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

pub fn pop_size(&self) -> usize

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

This value equals tensor.dims()[0].

pub fn genome_dim(&self) -> usize

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

This value equals tensor.dims()[1].

pub fn tensor(&self) -> &K::Tensor<B>

Borrows the backing tensor for this population’s kind.

The concrete type is K::Tensor<B> — a Tensor<B, 2> for Real, a Tensor<B, 2, Int> for Binary/Integer — with shape [pop_size, genome_dim]. Use it to pass the population to fitness functions or operator kernels without giving up ownership.

pub fn into_tensor(self) -> K::Tensor<B>

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).

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

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

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.

Errors

Returns ConstraintKind::Zero (as field "pop_size" or "genome_dim") if the tensor has zero rows or zero columns. Rejecting the empty case here names Population as the source instead of surfacing later as an opaque operator panic.

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),
).unwrap();
assert_eq!(pop.pop_size(), 2);
assert_eq!(pop.genome_dim(), 2);

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

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

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().

Errors

Returns ConstraintKind::Zero (as field "pop_size" or "genome_dim") if the tensor has zero rows or zero columns.

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),
).unwrap();
assert_eq!(pop.pop_size(), 3);
assert_eq!(pop.genome_dim(), 4);

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

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

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().

Errors

Returns ConstraintKind::Zero (as field "pop_size" or "genome_dim") if the tensor has zero rows or zero columns.

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),
).unwrap();
assert_eq!(pop.pop_size(), 2);
assert_eq!(pop.genome_dim(), 5);

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

pub fn new_permutation(tensor: Tensor<B, 2, Int>) -> Result<Self, ConfigError>

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

Each row is assumed to be a permutation of 0..genome_dim, but the constructor validates only shape — the per-row bijection invariant is not checked, mirroring how new_binary and new_integer leave element values unchecked. Shape is read from tensor.dims().

The permutation operators (Ant Colony Optimization over TSP/QAP) are planned for a future release; this constructor exists so downstream code can allocate and reference Population<B, Permutation> today.

Errors

Returns ConstraintKind::Zero (as field "pop_size" or "genome_dim") if the tensor has zero rows or zero columns.

Examples

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

let device = Default::default();
// 2 ants, each a permutation of a 4-node tour.
let data = TensorData::new(vec![0i64, 1, 2, 3,
                                2, 0, 3, 1], [2, 4]);
let pop = Population::<Flex, Permutation>::new_permutation(
    Tensor::from_data(data, &device),
).unwrap();
assert_eq!(pop.pop_size(), 2);
assert_eq!(pop.genome_dim(), 4);

Trait Implementations

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

where K::Tensor<B>: Clone,

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 + TensorGenome> Debug for Population<B, K>

where K::Tensor<B>: Debug,

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

Formats the value using the given formatter.