Struct ComplexityAnalysis 

pub struct ComplexityAnalysis {
    pub time_complexity: Option<String>,
    pub space_complexity: Option<String>,
    pub parallelization_potential: f64,
    pub sequential_dependencies: usize,
}

Complexity analysis of the computation

Fields

time_complexity: Option<String>

Asymptotic (Big-O) time complexity, when it can honestly be derived. A single ComputationGraph is one concrete, fixed-shape instance – it has no symbolic size parameter n to be asymptotic in, so there is nothing to honestly derive here today; always None, never a fabricated "O(n)". Concrete costs for the actual instance are available for real via FlopAnalysis::total_flops.

space_complexity: Option<String>

Asymptotic (Big-O) space complexity. Same honesty caveat as Self::time_complexity; concrete space for this instance is available for real via MemoryAnalysis::total_memory_usage.

parallelization_potential: f64

Real, structural parallelization-potential estimate in [0, 1]: 1 - (critical_path_length_in_nodes / node_count), i.e. the fraction of nodes that are not on the graph’s longest dependency chain and could in principle execute alongside it. 0.0 for a pure sequential chain (every node is on the critical path), approaching 1.0 for a wide, shallow graph. Computed from the graph’s real topology (see ComputationGraphAnalyzer::analyze_flop_usage) – never the old constant 0.7.

sequential_dependencies: usize

Sequential dependencies

Trait Implementations

impl Clone for ComplexityAnalysis

fn clone(&self) -> ComplexityAnalysis

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComplexityAnalysis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComplexityAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ComplexityAnalysis

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.