Struct Multiplexer 

pub struct Multiplexer { /* private fields */ }

The Boolean multiplexer of Koza (1992): k address bits select one of 2^k data bits, which is the output. The 11-multiplexer (k = 3, 2048 cases) is Koza’s; the 6-multiplexer (k = 2) is a smaller version.

Its primitives are Koza’s: the functions and, or, not and if (of three arguments), and the inputs a0 to a{k-1} (the address, a0 its least significant bit), then d0 to d{2^k-1} (the data). One type: the untyped genetic programming of the paper.

use genoxide::gp::boolean::Multiplexer;

let problem = Multiplexer::new(3)?; // Koza's 11-multiplexer
assert_eq!((problem.inputs(), problem.cases()), (11, 2048));
let set = problem.primitives();
// the right output everywhere: the data bit that the address selects
let tree = set.parse(
    "if(a2, if(a1, if(a0, d7, d6), if(a0, d5, d4)), if(a1, if(a0, d3, d2), if(a0, d1, d0)))",
)?;
assert_eq!(problem.errors(&tree), 0);
// one data bit is right in the cases that select it, and in half the others
assert_eq!(problem.errors(&set.parse("d0")?), 896);

Implementations

impl Multiplexer

pub fn new(address_bits: usize) -> Result<Self>

The multiplexer of address_bits address bits, 1 to 4: the 3-, 6-, 11- and 20-multiplexer.

Errors

Error::InvalidSetting (setting address_bits) for 0 or more than 4 address bits.

pub fn address_bits(&self) -> usize

The number of address bits.

pub fn reference(&self) -> &'static str

Koza (1992), the source of the problem and its primitives.

impl Multiplexer

pub fn primitives(&self) -> &PrimitiveSet<Logic>

The primitive set of the paper, over Logic: build a Gp from it, so the trees’ primitives are the problem’s.

pub fn inputs(&self) -> usize

The number of inputs.

pub fn cases(&self) -> u64

The number of cases of the truth table, 2^inputs. In case c, input i (in the order of the set’s terminals) is bit i of c.

pub fn targets(&self) -> &[u64]

The right outputs, 64 cases per word: case c at bit c % 64 of word c / 64.

pub fn outputs(&self, tree: &Tree) -> Vec<u64>

The tree’s outputs, as targets lays them out.

Panics

If the tree has primitives that aren’t the problem’s.

pub fn errors(&self, tree: &Tree) -> u64

The number of cases the tree gets wrong: the fitness, 0 at the optimum.

Panics

If the tree has primitives that aren’t the problem’s.

Trait Implementations

impl Clone for Multiplexer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Multiplexer

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

Formats the value using the given formatter.

impl FitnessFunction<Tree> for Multiplexer

fn evaluate(&self, tree: &Tree) -> f64

The number of cases the tree gets wrong, minimized.

type Output = f64

The type of a score.

fn is_batch(&self) -> bool

Whether the engine evaluates a generation with one call of evaluate_batch (true) rather than one call of evaluate per genome, in parallel if asked (false, the default). See Batch.

fn evaluate_batch(&self, genomes: &[&G]) -> Vec<Self::Output>

The scores of genomes, in their order: one evaluate each by default. Override it, and is_batch, to evaluate a generation at once, e.g. on a GPU.

fn provides(&self) -> Provided

What the function gives besides the fitness, such as the gradient of the score: nothing by default. An algorithm that needs an extra checks it once per run in Algorithm::prepare. Declare an extra here, and write it in evaluate_with.

fn evaluate_with(&self, genome: &G, extras: &mut Extras<'_>) -> Self::Output

The score of genome, with the extras that extras has buffers for (only ones that provides declares). The engine calls it instead of evaluate when the algorithm wants extras. The score must be the same as evaluate’s, to the bit. By default, evaluate(genome).

fn evaluate_batch_with( &self, genomes: &[&G], extras: &mut BatchExtras<'_>, ) -> Vec<Self::Output>

The scores of genomes, in their order, with the extras that extras has buffers for, a row per genome. The engine calls it instead of evaluate_batch for a batch function when the algorithm wants extras. By default, evaluate_batch(genomes) without extras, and one evaluate_with each otherwise.