Struct NCP 

pub struct NCP { /* private fields */ }

Neural Circuit Policy (NCP) wiring with biologically-inspired 4-layer architecture.

NCPs implement sparse, structured connectivity patterns inspired by the nervous system of C. elegans. This architecture provides:

• Parameter efficiency: Fewer synapses than fully-connected networks
• Interpretability: Clear information flow through defined layers
• Biological plausibility: Excitatory/inhibitory synapse types

Architecture

NCPs organize neurons into 4 functional layers:

Sensory Inputs ──► Inter Neurons ──► Command Neurons ──► Motor Neurons
   (input)         (processing)      (integration)       (output)
                                          │
                                          └──► Recurrent connections

Layer Descriptions

Layer	Role	Connectivity
Sensory	External inputs	→ Inter (via sensory_fanout)
Inter	Feature extraction	→ Command (via inter_fanout)
Command	Decision/integration	→ Motor + self (recurrent)
Motor	Output neurons	← Command (via motor_fanin)

Connectivity Parameters

• sensory_fanout: How many inter neurons each input connects to
• inter_fanout: How many command neurons each inter neuron connects to
• recurrent_command_synapses: Number of command→command recurrent connections
• motor_fanin: How many command neurons connect to each motor neuron

Example

use ncps::wirings::{NCP, Wiring};

// Create NCP with explicit layer sizes
let mut wiring = NCP::new(
    10,  // inter_neurons: feature processing
    8,   // command_neurons: integration layer
    4,   // motor_neurons: output size
    4,   // sensory_fanout: each input → 4 inter neurons
    4,   // inter_fanout: each inter → 4 command neurons
    6,   // recurrent_command_synapses
    4,   // motor_fanin: each motor ← 4 command neurons
    42,  // seed for reproducibility
);

// Must build before use
wiring.build(16);  // 16 input features

// Total neurons = inter + command + motor = 22
assert_eq!(wiring.units(), 22);
assert_eq!(wiring.output_dim(), Some(4));

Neuron ID Layout

Neurons are assigned IDs in this order:

[0..motor) [motor..motor+command) [motor+command..units)
  Motor        Command                Inter

When to Use

Use NCP directly when you need fine-grained control over:

• Exact layer sizes
• Connectivity density (fanout/fanin parameters)
• Recurrent connection count

For automatic parameter selection, use AutoNCP instead.

Panics

The constructor panics if constraints are violated:

• motor_fanin > command_neurons
• sensory_fanout > inter_neurons
• inter_fanout > command_neurons

Implementations

impl NCP

pub fn new( inter_neurons: usize, command_neurons: usize, motor_neurons: usize, sensory_fanout: usize, inter_fanout: usize, recurrent_command_synapses: usize, motor_fanin: usize, seed: u64, ) -> Self

pub fn from_config(config: WiringConfig) -> Self

Trait Implementations

impl Clone for NCP

fn clone(&self) -> NCP

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NCP

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

Formats the value using the given formatter.

impl Wiring for NCP

fn units(&self) -> usize

Returns the total number of neurons (hidden units) in this wiring.

fn input_dim(&self) -> Option<usize>

Returns the input dimension (number of input features), or None if not yet built.

fn output_dim(&self) -> Option<usize>

Returns the output dimension (number of motor neurons).

fn num_layers(&self) -> usize

Returns the number of logical layers in this wiring.

fn get_neurons_of_layer(&self, layer_id: usize) -> Vec<usize>

Returns the neuron IDs belonging to a specific layer.

fn get_type_of_neuron(&self, neuron_id: usize) -> &'static str

Returns the type of a neuron by its ID.

fn build(&mut self, input_dim: usize)

Builds the wiring by setting the input dimension and creating sensory connections.

fn adjacency_matrix(&self) -> &Array2<i32>

Returns the internal adjacency matrix representing neuron-to-neuron synapses.

fn sensory_adjacency_matrix(&self) -> Option<&Array2<i32>>

Returns the sensory adjacency matrix (input-to-neuron connections).

fn add_synapse(&mut self, src: usize, dest: usize, polarity: i32)

Adds or modifies an internal synapse between two neurons.

fn add_sensory_synapse(&mut self, src: usize, dest: usize, polarity: i32)

Adds or modifies a sensory synapse from an input feature to a neuron.

fn get_config(&self) -> WiringConfig

Creates a serializable configuration for this wiring.

fn is_built(&self) -> bool

Returns true if the wiring has been built (input dimension is set).

fn erev_initializer(&self) -> Array2<i32>

Returns the reversal potential initializer (same as adjacency matrix).

fn sensory_erev_initializer(&self) -> Option<Array2<i32>>

Returns the sensory reversal potential initializer.

fn synapse_count(&self) -> usize

Returns the total number of internal synapses (non-zero entries in adjacency matrix).

fn sensory_synapse_count(&self) -> usize

Returns the total number of sensory synapses (input-to-neuron connections).

fn input_required(&self) -> bool

Returns true if this wiring requires external input (has sensory connections).