Struct Graph 

pub struct Graph {
    pub node_features: Array2<f64>,
    pub edge_indices: Array2<usize>,
    pub edge_features: Option<Array2<f64>>,
    pub graph_features: Option<Array1<f64>>,
    pub num_nodes: usize,
    pub num_edges: usize,
}

Graph data structure

Fields

node_features: Array2<f64>

Node features

edge_indices: Array2<usize>

Edge indices (source, target pairs)

edge_features: Option<Array2<f64>>

Edge features

graph_features: Option<Array1<f64>>

Graph-level features

num_nodes: usize

Number of nodes

num_edges: usize

Number of edges

Implementations

impl Graph

pub fn new( node_features: Array2<f64>, edge_indices: Array2<usize>, edge_features: Option<Array2<f64>>, graph_features: Option<Array1<f64>>, ) -> Self

Create a new graph

Examples found in repository

examples/quantum_ml_ultrathink_showcase.rs (line 577)

fn generate_complex_graphs(num_graphs: usize) -> Result<Vec<Graph>> {
    let mut graphs = Vec::new();

    for graph_idx in 0..num_graphs {
        let num_nodes = 10 + graph_idx % 20; // 10-30 nodes
        let num_edges = num_nodes * 2; // Sparse graphs

        // Generate node features
        let node_features = Array2::from_shape_fn((num_nodes, 64), |(i, j)| {
            let node_factor = i as f64 * 0.1;
            let feature_factor = j as f64 * 0.05;
            (node_factor + feature_factor).sin() + fastrand::f64() * 0.1
        });

        // Generate edge indices (ensuring valid connections)
        let mut edge_indices = Array2::zeros((2, num_edges));
        for edge in 0..num_edges {
            edge_indices[[0, edge]] = fastrand::usize(..num_nodes);
            edge_indices[[1, edge]] = fastrand::usize(..num_nodes);
        }

        let graph = Graph::new(node_features, edge_indices, None, None);
        graphs.push(graph);
    }

    Ok(graphs)
}

fn extract_pde_features_with_qpinn() -> Result<Array1<f64>> {
    // Simulate PDE feature extraction
    Ok(Array1::from_shape_fn(20, |i| (i as f64 * 0.2).exp() * 0.1))
}

fn process_temporal_with_qrc(features: &Array1<f64>) -> Result<Array2<f64>> {
    // Simulate temporal processing
    let temporal_length = 10;
    Ok(Array2::from_shape_fn(
        (temporal_length, features.len()),
        |(t, f)| features[f] * (t as f64 * 0.1).cos(),
    ))
}

fn create_relationship_graph(patterns: &Array2<f64>) -> Result<Graph> {
    let num_nodes = patterns.nrows();
    let node_features = patterns.clone();

    // Create edges based on similarity
    let mut edges = Vec::new();
    for i in 0..num_nodes {
        for j in i + 1..num_nodes {
            if fastrand::f64() < 0.3 {
                // 30% connection probability
                edges.push(i);
                edges.push(j);
            }
        }
    }

    let num_edges = edges.len() / 2;
    let edge_indices = Array2::from_shape_vec((2, num_edges), edges)?;

    Ok(Graph::new(node_features, edge_indices, None, None))
}

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

Get neighbors of a node

Examples found in repository

examples/quantum_ml_ultrathink_showcase.rs (line 623)

fn analyze_with_qgat(graph: &Graph) -> Result<Array1<f64>> {
    // Simulate QGAT analysis
    Ok(Array1::from_shape_fn(graph.num_nodes, |i| {
        let neighbors = graph.get_neighbors(i);
        neighbors.len() as f64 * 0.1 + fastrand::f64() * 0.05
    }))
}

pub fn get_adjacency_matrix(&self) -> Array2<f64>

Get adjacency matrix

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.