Struct GeometricNetwork 

pub struct GeometricNetwork<const P: usize, const Q: usize, const R: usize> { /* private fields */ }

A network where nodes are embedded in geometric algebra space

Each node is represented as a multivector in Cl(P,Q,R), enabling geometric operations like distance computation and geometric products for information diffusion.

Implementations

impl<const P: usize, const Q: usize, const R: usize> GeometricNetwork<P, Q, R>

pub fn new() -> Self

Create a new empty geometric network

pub fn with_capacity(num_nodes: usize, num_edges: usize) -> Self

Create a network with pre-allocated capacity

pub fn add_node(&mut self, position: Multivector<P, Q, R>) -> usize

Add a node at the specified geometric position

Returns the index of the newly added node.

pub fn add_node_with_metadata( &mut self, position: Multivector<P, Q, R>, metadata: NodeMetadata, ) -> usize

Add a node with associated metadata

Returns the index of the newly added node.

pub fn add_edge( &mut self, source: usize, target: usize, weight: f64, ) -> NetworkResult<()>

Add a directed edge between two nodes

pub fn add_undirected_edge( &mut self, a: usize, b: usize, weight: f64, ) -> NetworkResult<()>

Add an undirected edge (creates two directed edges)

pub fn num_nodes(&self) -> usize

Get the number of nodes in the network

pub fn num_edges(&self) -> usize

Get the number of edges in the network

pub fn get_node(&self, index: usize) -> Option<&Multivector<P, Q, R>>

Get a reference to a node’s position

pub fn get_metadata(&self, index: usize) -> Option<&NodeMetadata>

Get metadata for a node

pub fn neighbors(&self, node: usize) -> Vec<usize>

Get all neighbors of a node

pub fn degree(&self, node: usize) -> usize

Get the degree (number of outgoing edges) of a node

pub fn edges(&self) -> &[GeometricEdge]

Get all edges in the network

pub fn geometric_distance( &self, node1: usize, node2: usize, ) -> NetworkResult<f64>

Compute geometric distance between two nodes

Uses the natural norm in Clifford algebra space: ||a - b|| where a and b are the multivector positions of the nodes.

pub fn compute_geometric_centrality(&self) -> NetworkResult<Vec<f64>>

Compute geometric centrality for all nodes

Geometric centrality is based on the inverse of the sum of geometric distances to all other nodes. Nodes closer to the geometric center of the network have higher centrality.

pub fn compute_betweenness_centrality(&self) -> NetworkResult<Vec<f64>>

Compute betweenness centrality for all nodes

Measures how often each node lies on shortest paths between other pairs of nodes using graph-theoretic shortest paths.

pub fn compute_all_pairs_shortest_paths(&self) -> NetworkResult<Vec<Vec<f64>>>

Compute all-pairs shortest paths using Floyd-Warshall algorithm

Returns a matrix where element [i][j] is the shortest path distance from node i to node j using edge weights.

pub fn shortest_path( &self, source: usize, target: usize, ) -> NetworkResult<Option<(Vec<usize>, f64)>>

Find shortest path between two nodes using Dijkstra’s algorithm

Returns the path as a vector of node indices and the total distance. Uses edge weights for distance computation.

pub fn shortest_geometric_path( &self, source: usize, target: usize, ) -> NetworkResult<Option<(Vec<usize>, f64)>>

Find shortest path using geometric distances

Uses geometric distances between multivector positions rather than edge weights. This provides a direct path in the geometric algebra space.

pub fn to_tropical_network(&self) -> NetworkResult<TropicalNetwork>

Convert to tropical network for efficient path operations

Creates a TropicalNetwork representation using edge weights, enabling fast shortest path computations via tropical algebra.

pub fn find_communities( &self, num_communities: usize, ) -> NetworkResult<Vec<Community<P, Q, R>>>

Detect communities using geometric clustering

Groups nodes based on their geometric proximity in the multivector space. Uses k-means style clustering with geometric distance metric.

pub fn simulate_diffusion( &self, initial_sources: &[usize], max_steps: usize, diffusion_rate: f64, ) -> NetworkResult<PropagationAnalysis>

Simulate information diffusion through the network

Models how information spreads using geometric products between node positions. Initial information is placed at source nodes and propagates based on edge weights and geometric similarity.

pub fn spectral_clustering( &self, num_clusters: usize, ) -> NetworkResult<Vec<Vec<usize>>>

Perform spectral clustering using the graph Laplacian

Uses eigenvalue decomposition of the normalized Laplacian matrix to identify community structure in the network.

Trait Implementations

impl<const P: usize, const Q: usize, const R: usize> Clone for GeometricNetwork<P, Q, R>

fn clone(&self) -> GeometricNetwork<P, Q, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const P: usize, const Q: usize, const R: usize> Debug for GeometricNetwork<P, Q, R>

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

Formats the value using the given formatter.

impl<const P: usize, const Q: usize, const R: usize> Default for GeometricNetwork<P, Q, R>

fn default() -> Self

Returns the “default value” for a type.