Struct VNode 

pub struct VNode<D, T = f32>
where
    D: RawDriver<Triad>,
{ /* private fields */ }

This struct manifests the partitions automatically allocated by the runtime as virtualized workspaces responsible for maintaining their plant’s. Their capabilities are defined by the current operator, allowing a node to become an observer, agent, etc

Node’s equip their plants (or drivers) with everything needed to successfully execute a given transaction, providing storage and networking capabilities while abstracting away platform-specific logic. This enables plant’s to retain their topological and mathematical properties and reduces overhead in the process.

VNode’s are rely on a topological memory system to facilitate various operations. This memory system is responsible for storing and managing the topological features of the plant, such as the current state, critical points, and navigational history.

Additionally, each instance is equipped with its own neural network designed to materialize the surface of the node’s headspace. This process specifically speaks to the dynamic configuration of a neural network with respect to a topological entity. This provides the system with an additional degree of freedom when it comes to learning as certain engines are capable of learning the rules of headspace leaving the surface to predict and learn more traditional patterns.

Implementations

impl<T> VNode<Plant<NeuralEngine<T>>, T>

where T: Float + FromPrimitive + ScalarOperand, NeuralEngine<T>: ComputationalEngine<usize, [usize; 3], Store = Vec<usize>>,

pub fn adapt_weights_to_target( &mut self, pattern: Tail<usize, usize>, ) -> Result<(), ActorError>

where T: Sum + NumAssign,

pub fn execute_with_stored(&mut self) -> Result<(), ActorError>

where T: Sum + NumAssign,

execute the driver with the stored data

pub fn decode_driver_output(&self, outputs: Array1<T>) -> Tail<usize, usize>

use the driver to decode the outputs of the network into a meaningful tail

impl<D, T> VNode<D, T>

where D: RawDriver<Triad>, T: Float + FromPrimitive + ToPrimitive + NumAssign + ScalarOperand + Sum + FromStr,

pub fn adapt_stability_patterns( &mut self, source_class: Triads, ) -> Result<(), ActorError>

Apply learned stability patterns from another triad class to the current one

pub fn adapt_surface_to_external_patterns<I>( &mut self, patterns: I, ) -> Result<(), ActorError>

where I: IntoIterator<Item = Vec<usize>>,

Adapt the surface network weights based on patterns from another node

pub fn adjust_surface_parameters( &mut self, target: &(T, T, T), rate: T, ) -> Result<(), ActorError>

Adjust surface parameters towards target parameters

pub fn apply_federated_gradients( &mut self, averaged_gradients: &HashMap<String, Vec<Vec<T>>>, ) -> Result<(), ActorError>

Apply federated gradients to local model

pub fn calculate_adaptive_feature_target(&self) -> usize

where T: FromStr,

Calculate adaptive target for maximum feature count

pub fn consolidate_similar_patterns( &mut self, similarity_threshold: T, ) -> Result<usize, ActorError>

Consolidate similar patterns to reduce memory usage

pub fn contextualize(&mut self) -> Result<ActorContext<T>, ActorError>

Get contextual information about the current state

pub fn create_stability_patterns_for_class( &self, class: Triads, ) -> Vec<StabilityPattern<T>>

Create stability patterns specific to the current headspace

pub fn distance_to_critical_point(&self, name: &str) -> Option<usize>

Calculate distance from headspace root to critical point

pub fn distance_to_point(&self, point: usize) -> usize

Calculate distance to a point

pub fn ensure_surface_network( &mut self, ) -> Result<&mut SurfaceNetwork<T>, ActorError>

where StandardNormal: Distribution<T>,

pub fn extract_knowledge_patterns(&self) -> Result<Vec<Vec<usize>>, ActorError>

Extract knowledge patterns in a discrete form

pub fn extract_learning_gradients( &self, ) -> Result<HashMap<String, Vec<T>>, ActorError>

Extract learning gradients for federated learning

pub fn find_related_triads(&self) -> Vec<Triad>

Find features related to the current triad

pub fn find_paths_to_point(&self, target: usize) -> Vec<Vec<LPR>>

Find paths to a triad containing the target pitch

pub fn get_frequently_visited_triads( &self, min_occurrences: usize, ) -> Vec<Triad>

Get a list of triads that have been frequently visited

pub fn get_convergence_rate(&self) -> T

Get convergence rate for learning

pub fn get_feature_quality(&self) -> T

Get feature quality metric

pub fn get_learning_accuracy(&self) -> T

where T: FromStr,

Get the current learning accuracy

pub fn get_memory_statistics(&self) -> MemoryStatistics<T>

Get statistics about the memory state

pub fn get_stability_patterns(&self) -> Option<Vec<StabilityPattern<T>>>

where SurfaceModel<T>: Predict<Array1<T>, Output = Array1<T>>,

Get learned stability patterns from this node’s surface network

pub fn get_surface_parameters(&self) -> (T, T, T)

Get surface network parameters

pub fn identify_critical_point(&mut self, name: &str, pitch: usize)

Identify a critical point in the tonal space

pub fn init_surface(&mut self) -> Result<(), ActorError>

where StandardNormal: Distribution<T>,

pub fn integrate_external_knowledge( &mut self, patterns: &[Vec<usize>], source_id: &EdgeId, ) -> Result<(), ActorError>

where T: Display + FromStr,

Integrate knowledge from another node

pub fn learn_headspace(&mut self) -> Result<(), ActorError>

Learn headspace based on its structure and critical points

pub fn learn_pattern<X, Y, Z>( &mut self, inputs: &X, targets: &Y, iterations: usize, ) -> Result<(), ActorError>

where SurfaceModel<T>: Train<X, Y, Output = Z>,

Learn a pattern from inputs within current headspace

pub fn learn_stability_characteristics(&mut self) -> Result<(), ActorError>

where D: TriadDriver,

Learn stability characteristics specific to the current chord class

pub fn learn_stability_patterns( &mut self, _patterns: &[StabilityPattern], ) -> Result<(), ActorError>

Learn stability patterns from other nodes

pub fn learn_surface(&mut self) -> Result<(), ActorError>

Learn the surface defined by critical points

pub fn learn_transformation_sequence( &mut self, transforms: &[LPR], ) -> Result<(), ActorError>

Learn a transformation sequence

pub fn navigate_to_critical_point( &mut self, point_name: &str, ) -> Result<Vec<LPR>, ActorError>

where D: TriadDriver,

Navigate to satisfy a specific critical point

pub fn optimize_memory( &mut self, max_features: usize, ) -> Result<VirtualMemoryAnalysis<T>, ActorError>

Optimize memory usage with intelligent feature management

pub fn predict_next_transformation(&self) -> Option<LPR>

Predict the next likely transformation based on patterns in memory

pub fn process_message( &mut self, source: EdgeId, message: &[u8], ) -> Result<(), ActorError>

Process a message from another node

pub fn process_surface<X, Y>(&self, input: &X) -> Result<Y, ActorError>

where SurfaceModel<T>: Predict<X, Output = Y>,

Process an input through the surface network to predict behavior

pub fn propose_transformation(&self) -> Option<LPR>

Have the active operator propose a transformation (if supported)

pub fn resource_requirements(&self) -> (usize, usize)

Get the resource requirements for this node

pub fn prune_low_importance_features( &mut self, threshold: T, ) -> Result<(), ActorError>

Prune low-importance features

pub fn set_name(&mut self, name: &str)

Set the name of the node

pub fn share_patterns<E>( &self, target: &mut VNode<E, T>, ) -> Result<(), ActorError>

where E: Driver<Triad>,

Share patterns with another node

pub fn train_surface<X, Y, Z>( &mut self, inputs: &X, targets: &Y, ) -> Result<Z, ActorError>

where T: Debug + Send + Sync + Signed + FftNum, SurfaceModel<T>: Train<X, Y, Output = Z>, StandardNormal: Distribution<T>,

Train the surface network on a pattern

pub fn transform(&mut self, transform: LPR) -> Result<(), ActorError>

where D: TriadDriver,

Apply a transformation to the plant and record in memory

pub fn transform_batch(&mut self, transforms: &[LPR]) -> Result<(), ActorError>

where D: TriadDriver,

Efficiently apply multiple transformations in batch

pub fn update_surface_headspace(&mut self) -> Result<(), ActorError>

Update the surface network when the headspace changes

impl<D, T> VNode<D, T>

where D: RawDriver<Triad>,

pub fn new() -> Self

where D: Default, T: Float + FromPrimitive + ToPrimitive,

initialize a new virual node with a default driver

pub fn from_driver(plant: D) -> Self

where T: Float + FromPrimitive + ToPrimitive,

Create a new virtual node with topological memory

pub fn from_headspace(headspace: Triad) -> Self

where D: Driver<Triad>, T: Float + FromPrimitive + ToPrimitive,

initialize a new virtual node from the given headspace

pub const fn id(&self) -> Id

returns a copy of the node id

pub fn class(&self) -> Triads

Return the triad class of the underlying plant

pub const fn critical_points(&self) -> &HashMap<String, usize>

return an immutable reference to the critical points

pub const fn critical_points_mut(&mut self) -> &mut HashMap<String, usize>

return a mutable reference to the critical points

pub const fn driver(&self) -> &D

return an immutable reference to the plant

pub const fn driver_mut(&mut self) -> &mut D

return a mutable reference to the plant

pub fn headspace_mut(&mut self) -> &mut Triad

returns a mutable reference to the node’s headspace

pub fn last_context(&self) -> Option<&(ActorContext<T>, Instant)>

returns an immutable reference to the last context

pub fn last_context_mut(&mut self) -> Option<&mut (ActorContext<T>, Instant)>

returns a mutable reference to the last context

pub const fn store(&self) -> &TopoLedger<T>

return an immutable reference to the memory system

pub const fn store_mut(&mut self) -> &mut TopoLedger<T>

return a mutable reference to the memory system

pub const fn memory(&self) -> &TopoLedger<T>

👎Deprecated since 0.3.0: use store instead

pub const fn memory_mut(&mut self) -> &mut TopoLedger<T>

👎Deprecated since 0.3.0: use store_mut instead

pub const fn operator(&self) -> &Operator<T>

returns an immutable reference to the actor of the node

pub const fn operator_mut(&mut self) -> &mut Operator<T>

returns a mutable reference to the actor of the node

pub fn surface(&self) -> Option<&SurfaceNetwork<T>>

returns an immutable reference to the surface network

pub fn surface_mut(&mut self) -> Option<&mut SurfaceNetwork<T>>

returns a mutable reference to the surface network

pub const fn tonic_history(&self) -> &Vec<usize>

returns an immutable reference the tonic history

pub const fn tonic_history_mut(&mut self) -> &mut Vec<usize>

returns a mutable reference to the history of the node

pub fn set_id(&mut self, id: Id) -> &mut Self

update the id and return a mutable reference to the node

pub fn set_critical_points( &mut self, critical_points: HashMap<String, usize>, ) -> &mut Self

update the current critical points and return a mutable reference to the node

pub fn set_driver(&mut self, driver: D) -> &mut Self

where T: Float + FromPrimitive + ToPrimitive,

update the current driver and return a mutable reference to the node

pub fn set_operator(&mut self, operator: Operator<T>) -> &mut Self

update the current operator and return a mutable reference to the node

pub fn set_store(&mut self, store: TopoLedger<T>) -> &mut Self

update the current memory system and return a mutable reference to the node

pub fn set_surface(&mut self, surface: Option<SurfaceNetwork<T>>) -> &mut Self

update the current surface network and return a mutable reference to the node

pub fn set_tonic_history(&mut self, tonic_history: Vec<usize>) -> &mut Self

update the current tonic history and return a mutable reference to the node

pub fn with_critical_points( self, critical_points: HashMap<String, usize>, ) -> Self

consumes the node to create another with the given critical points

pub fn with_driver(self, driver: D) -> Self

consumes the node to create another with the given driver

pub fn with_id(self, id: Id) -> Self

consumes the node to create another with the given id

pub fn with_operator(self, operator: Operator<T>) -> Self

consumes the node to create another with the given operator

pub fn with_store(self, store: TopoLedger<T>) -> Self

consumes the node to create another with the given memory system

pub fn with_surface(self, surface: Option<SurfaceNetwork<T>>) -> Self

consumes the node to create another with the given surface network

pub fn with_tonic_history(self, tonic_history: Vec<usize>) -> Self

consumes the node to create another with the given tonic history

pub fn add_critical_point( &mut self, name: PointKind, pitch_class: usize, ) -> Option<usize>

consumes the node to create another with the given surface network add a critical point to the plant and return the previous value, if it exists.

pub fn calculate_centroid(&self) -> Option<[T; 2]>

where T: Float + FromPrimitive,

compute the centroid of the headspace

pub fn headspace(&self) -> &Triad

returns an immutable reference to the node’s headspace

pub const fn kind(&self) -> OperatorKind

Get the current operator mode

pub fn record_navigation(&mut self, origin: &Triad, transforms_used: &[LPR])

where T: Float + FromPrimitive + ToPrimitive,

Record a successful navigation from one point to another

pub fn remove_critical_point(&mut self, name: PointKind) -> Option<usize>

Remove a critical point from the plant

pub fn critical_point_count(&self) -> usize

👎Deprecated since 0.3.0: use total_critical_points instead

pub fn feature_count(&self) -> usize

👎Deprecated since 0.3.0: use total_features instead

pub fn total_critical_points(&self) -> usize

returns the number of critical points

pub fn total_features(&self) -> usize

Get the number of features in memory

pub fn get_notes(&self) -> [usize; 3]

Return the notes (alphabet) of the underlying plant

pub fn get_tonic(&self) -> Note

get the tonic (root) of the headspace

pub fn has_surface_network(&self) -> bool

returns true if the node has initialized a surface network

pub fn record_state(&mut self) -> usize

where T: Float + FromPrimitive + ToPrimitive,

Record the current state in memory

pub fn set_last_context(&mut self, context: ActorContext<T>)

set the last context of the node

pub fn set_operator_by_kind(&mut self, mode: OperatorKind)

where T: Sum + Float + FromPrimitive + NumAssign + ToPrimitive,

set the operator by kind

Trait Implementations

impl<D, T: Clone> Clone for VNode<D, T>

where D: RawDriver<Triad> + Clone,

fn clone(&self) -> VNode<D, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D, T: Debug> Debug for VNode<D, T>

where D: RawDriver<Triad> + Debug,

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

Formats the value using the given formatter.

impl<D, T> Default for VNode<D, T>

where D: Default + RawDriver<Triad>, T: Default + Float + FromPrimitive,

fn default() -> Self

Returns the “default value” for a type.

impl<D, T> Hash for VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, D, T> PartialEq<&'a VNode<D, T>> for VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: PartialEq,

fn eq(&self, other: &&'a VNode<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, D, T> PartialEq<&'a mut VNode<D, T>> for VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: PartialEq,

fn eq(&self, other: &&'a mut VNode<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D, T> PartialEq<VNode<D, T>> for &VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: PartialEq,

fn eq(&self, other: &VNode<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D, T> PartialEq<VNode<D, T>> for &mut VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: PartialEq,

fn eq(&self, other: &VNode<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D, T> PartialEq for VNode<D, T>

where D: RawDriver<Triad>, Operator<T>: PartialEq,

fn eq(&self, other: &VNode<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D, T> Eq for VNode<D, T>

where D: RawDriver<Triad>, T: PartialEq,