Struct RoyalRoad 

pub struct RoyalRoad {
    pub schema_size: usize,
    pub num_schemas: usize,
}

Royal Road function

Tests the “building block hypothesis” - fitness is the count of complete schemas (contiguous blocks of 1s). Rewards completing full blocks rather than partial solutions.

For example, with schema_size=8 and num_schemas=4 (32-bit string):

• 11111111 00000000 11111111 00000000 has fitness 2 (two complete blocks)
• 11111110 11111111 11111111 11111111 has fitness 3 (one incomplete)

Fields

schema_size: usize

Size of each schema (block of consecutive 1s)

num_schemas: usize

Number of schemas in the genome

Implementations

impl RoyalRoad

pub fn new(schema_size: usize, num_schemas: usize) -> Self

Create a new Royal Road function

Arguments

• schema_size - Number of bits in each schema (typically 8)
• num_schemas - Number of schemas (typically 8)

pub fn standard() -> Self

Standard Royal Road configuration (8x8 = 64 bits)

pub fn genome_length(&self) -> usize

Total genome length required

pub fn count_complete_schemas(&self, bits: &[bool]) -> usize

Count the number of complete schemas

Trait Implementations

impl Clone for RoyalRoad

fn clone(&self) -> RoyalRoad

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RoyalRoad

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

Formats the value using the given formatter.

impl Fitness for RoyalRoad

type Genome = BitString

The genome type being evaluated

type Value = usize

The fitness value type

fn evaluate(&self, genome: &Self::Genome) -> usize

Evaluate fitness (higher = better by convention)

fn as_log_likelihood(&self, genome: &Self::Genome, temperature: f64) -> f64

Convert fitness to log-likelihood for probabilistic selection

fn gradient(&self, _genome: &Self::Genome) -> Option<Vec<f64>>

Optional: Provide gradient for gradient-assisted mutation