Module mapping_scirs2 

Advanced qubit mapping using SciRS2 graph algorithms

This module provides state-of-the-art qubit mapping and routing algorithms leveraging SciRS2’s comprehensive graph analysis capabilities.

Re-exports

pub use crate::calibration::DeviceCalibration;

pub use crate::routing_advanced::AdvancedRoutingResult;

pub use crate::routing_advanced::RoutingMetrics;

pub use crate::routing_advanced::SwapOperation;

pub use crate::topology::HardwareTopology;

pub use crate::DeviceError;

pub use crate::DeviceResult;

pub use analytics::*;

pub use config::*;

pub use core::*;

pub use graph_analysis::*;

pub use mapping_algorithms::*;

pub use ml_integration::*;

pub use optimization::*;

pub use types::*;

pub use utils::*;

Modules

analytics

Analytics and monitoring for mapping performance

config

Configuration types for SciRS2 mapping

core

Core SciRS2 qubit mapper implementation

graph_analysis

Graph analysis components and result types

mapping_algorithms

Mapping algorithm implementations

ml_integration

Machine learning integration for advanced mapping

optimization

Advanced optimization configurations and algorithms

seq

Sequence random operations for SCIRS2 ecosystem

types

Type definitions for SciRS2 mapping

utils

Utility functions and test helpers for SciRS2 mapping

Structs

Arc

A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.

AsyncMutex

An asynchronous Mutex-like type.

AsyncRwLock

An asynchronous reader-writer lock.

Axis

An axis index.

BTreeMap

An ordered map based on a B-Tree.

Bernoulli

The Bernoulli distribution Bernoulli(p).

Beta

Beta distribution for modeling proportions and confidence intervals

BetaDist

The Beta distribution Beta(α, β).

BinaryHeap

A priority queue implemented with a binary heap.

Binomial

The binomial distribution Binomial(n, p).

Categorical

Categorical distribution for discrete outcomes

Cauchy

The Cauchy distribution Cauchy(x₀, γ).

ChiSquared

The chi-squared distribution χ²(k).

Circuit

A quantum circuit with a fixed number of qubits

DiGraph

A directed graph structure

DirichletDist

The Dirichlet distribution Dirichlet(α₁, α₂, ..., αₖ).

Duration

A Duration type to represent a span of time, typically used for system timeouts.

Edge

Represents an edge in a graph

Exponential

The exponential distribution Exp(λ).

FisherF

The Fisher F-distribution F(m, n).

Gamma

The Gamma distribution Gamma(k, θ).

Graph

An undirected graph structure

HashMap

A hash map implemented with quadratic probing and SIMD lookup.

HashSet

A hash set implemented as a HashMap where the value is ().

Instant

A measurement of a monotonically nondecreasing clock. Opaque and useful only with Duration.

LogNormal

The log-normal distribution ln N(μ, σ²).

Mutex

A mutual exclusion primitive useful for protecting shared data

NodeIndex

Node identifier.

Normal

The Normal distribution N(μ, σ²).

PetGraph

Graph<N, E, Ty, Ix> is a graph datastructure using an adjacency list representation.

Poisson

The Poisson distribution Poisson(λ).

QubitId

A transparent wrapper around a qubit identifier

Random

Enhanced random number generator for scientific computing

RwLock

A reader-writer lock

StudentT

The Student t-distribution t(ν).

SystemTime

A measurement of the system clock, useful for talking to external entities like the file system or other processes.

Uniform

Sample values uniformly between two bounds.

VecDeque

A double-ended queue implemented with a growable ring buffer.

Weibull

The Weibull distribution Weibull(λ, k).

WeightedChoice

Weighted choice distribution for selecting from items with weights

Enums

GraphError

Error type for graph processing operations

Ordering

An Ordering is the result of a comparison between two values.

QuantRS2Error

Common error types for quantum operations

Traits

Deserialize

A data structure that can be deserialized from any data format supported by Serde.

DistributionExt

Extension trait for distributions to create arrays directly

GateOp

Trait for quantum gate operations

Node

A trait representing a node in a graph

OptimizedArrayRandom

Trait for optimized random array generation

Rng

User-level interface for RNGs

RngCore

Implementation-level interface for RNGs

ScientificSliceRandom

Enhanced slice random operations for scientific computing

SeedableRng

A random number generator that can be explicitly seeded.

Serialize

A data structure that can be serialized into any data format supported by Serde.

SliceRandom

Extension trait on slices, providing shuffling methods.

Functions

astar_search

A* search algorithm for finding the shortest path with a heuristic

astar_search_digraph

A* search for directed graphs

barabasi_albert_graph

Generates a Barabási–Albert preferential attachment graph

betweenness_centrality

Betweenness centrality for nodes

boolean

Generate a random boolean

closeness_centrality

Closeness centrality for nodes

clustering_coefficient

Calculates the local clustering coefficient for each node in an undirected graph

corrcoef

Compute a correlation matrix for a set of variables.

diameter

Computes the diameter of a graph

dijkstra_path

Finds the shortest path between source and target nodes using Dijkstra’s algorithm (modern API)

eig

Compute the eigenvalues and right eigenvectors of a square matrix.

eigenvector_centrality

Eigenvector centrality

erdos_renyi_graph

Generates an Erdős–Rényi random graph

graph_density

Calculates the global clustering coefficient (transitivity) of a graph

k_core_decomposition

K-core decomposition of a graph

louvain_communities_result

Detects communities in a graph using the Louvain method (modern API)

matrix_norm

Compute a matrix norm.

maximum_bipartite_matching

Finds a maximum bipartite matching using the Hungarian algorithm

mean

Compute the arithmetic mean of a data set.

minimize

Main minimize function for unconstrained optimization

minimum_cut

Find minimum cut in a graph using global min-cut algorithm

minimum_spanning_tree

Kruskal’s algorithm for finding minimum spanning tree

normal

Generate a standard normal random number (mean=0, std=1)

normal_array

Generate a random array with normal distribution

pagerank

PageRank algorithm for computing node importance

pearsonr

Calculates the Pearson correlation coefficient and p-value for testing non-correlation.

radius

Computes the radius of a graph

random_normal_array

Generate a random array with normal distribution

random_uniform_array

Convenience functions for common array operations Generate a random array with uniform distribution [0, 1)

seeded_rng

Create a seeded random number generator (convenience function)

spectral_radius

Computes the spectral radius of a graph

std

Compute the standard deviation of a data set.

strongly_connected_components

Finds all strongly connected components in a directed graph using Tarjan’s algorithm

svd

Compute the singular value decomposition of a matrix.

thread_rng

Get a thread-local random number generator (convenience function)

topological_sort

Topological sort for directed acyclic graphs

uniform

Generate a uniform random number in [0, 1)

uniform_array

Generate a random array with uniform distribution

watts_strogatz_graph

Generates a Watts-Strogatz small-world graph

Type Aliases

Array1

one-dimensional array

Array2

two-dimensional array

ArrayView1

one-dimensional array view

ArrayView2

two-dimensional array view

GraphResult

Result type for graph processing operations

LinalgResult

Result type for linear algebra operations

NormalDist

OptimizeResult

Result type for optimization operations

QuantRS2Result

Result type for quantum operations

StdRng

ThreadRng

UnGraph

A Graph with undirected edges.

UniformDist

Derive Macros

Deserialize

Serialize