Struct StandardDeviationAnalyzer 

pub struct StandardDeviationAnalyzer { /* private fields */ }

Analyzer that computes standard deviation and variance.

This analyzer calculates both population and sample standard deviation, providing insights into data variability and spread. It uses numerically stable algorithms to avoid precision loss with large datasets.

Example

use term_guard::analyzers::advanced::StandardDeviationAnalyzer;
use datafusion::prelude::*;

let ctx = SessionContext::new();
// Register your data table

let analyzer = StandardDeviationAnalyzer::new("temperature");
let state = analyzer.compute_state_from_data(&ctx).await?;
let metric = analyzer.compute_metric_from_state(&state)?;

if let MetricValue::Map(stats) = metric {
    println!("Temperature statistics:");
    println!("  Standard Deviation: {:?}", stats.get("std_dev"));
    println!("  Variance: {:?}", stats.get("variance"));
    println!("  Sample Std Dev: {:?}", stats.get("sample_std_dev"));
}

Implementations

impl StandardDeviationAnalyzer

pub fn new(column: impl Into<String>) -> Self

Creates a new standard deviation analyzer for the specified column.

pub fn column(&self) -> &str

Returns the column being analyzed.

Trait Implementations

impl Analyzer for StandardDeviationAnalyzer

type State = StandardDeviationState

The state type for incremental computation.

type Metric = MetricValue

The metric type produced by this analyzer.

fn compute_state_from_data<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 SessionContext, ) -> Pin<Box<dyn Future<Output = AnalyzerResult<Self::State>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Computes the state from the input data.

fn compute_metric_from_state( &self, state: &Self::State, ) -> AnalyzerResult<Self::Metric>

Computes the final metric from the accumulated state.

fn name(&self) -> &str

Returns the name of this analyzer.

fn description(&self) -> &str

Returns a description of what this analyzer computes.

fn columns(&self) -> Vec<&str>

Returns the column(s) this analyzer operates on, if any.

fn merge_states(&self, states: Vec<Self::State>) -> AnalyzerResult<Self::State>

Merges multiple states into a single state.

fn metric_key(&self) -> String

Returns the metric key for storing results.

fn is_combinable(&self) -> bool

Indicates whether this analyzer can be combined with others.

impl Clone for StandardDeviationAnalyzer

fn clone(&self) -> StandardDeviationAnalyzer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StandardDeviationAnalyzer

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

Formats the value using the given formatter.