Struct ModelAnalytics 

pub struct ModelAnalytics {
    pub quality_score: f64,
    pub complexity_assessment: ComplexityAssessment,
    pub best_practices: BestPracticeReport,
    pub distributions: DistributionAnalysis,
    pub dependency_metrics: DependencyMetrics,
    pub anomalies: Vec<Anomaly>,
    pub recommendations: Vec<Recommendation>,
    pub benchmark: BenchmarkComparison,
}

Comprehensive model analytics report

Fields

quality_score: f64

Overall quality score (0-100)

complexity_assessment: ComplexityAssessment

Complexity assessment across multiple dimensions

best_practices: BestPracticeReport

Best practice compliance

distributions: DistributionAnalysis

Statistical distributions

dependency_metrics: DependencyMetrics

Dependency and coupling metrics

anomalies: Vec<Anomaly>

Detected anomalies

recommendations: Vec<Recommendation>

Actionable recommendations

benchmark: BenchmarkComparison

Benchmarking against industry standards

Implementations

impl ModelAnalytics

pub fn analyze(aspect: &Aspect) -> Self

Perform comprehensive analysis on an Aspect model

Arguments

• aspect - The aspect to analyze

Examples

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let analytics = ModelAnalytics::analyze(aspect);
println!("Quality Score: {}/100", analytics.quality_score);

impl ModelAnalytics

pub fn compute_kendall_correlations(&self) -> PropertyCorrelationMatrix

Compute Kendall tau correlations between model properties

Kendall tau is a non-parametric measure of ordinal association. It measures the similarity of orderings when ranked by each variable. More robust to errors and discrepancies in data than other methods.

Returns

A correlation matrix with Kendall tau correlation coefficients and insights

Example

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let analytics = ModelAnalytics::from_aspect(aspect)?;
let kendall = analytics.compute_kendall_correlations();

println!("Kendall tau correlation matrix computed");
println!("Features analyzed: {:?}", kendall.feature_names);
for insight in &kendall.insights {
    println!("  {} <-> {}: {:.3}", insight.feature1, insight.feature2, insight.coefficient);
}

impl ModelAnalytics

pub fn compute_partial_correlations(&self) -> PropertyCorrelationMatrix

Compute partial correlations between model properties

Partial correlation measures the relationship between two variables while controlling for (removing the effect of) other variables. This reveals the true direct relationship between features, independent of confounding factors.

Mathematical Background

For variables X, Y with control variable Z, the partial correlation is:

r(X,Y|Z) = (r(X,Y) - r(X,Z) * r(Y,Z)) / sqrt((1 - r(X,Z)²) * (1 - r(Y,Z)²))

Returns

A correlation matrix with partial correlation coefficients controlling for all other features

Example

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let analytics = ModelAnalytics::analyze(aspect)?;
let partial = analytics.compute_partial_correlations();

println!("Partial correlation matrix computed");
println!("Method: {}", partial.method);
for insight in &partial.insights {
    println!("  {} <-> {}: {:.3} (controlling for others)",
             insight.feature1, insight.feature2, insight.coefficient);
}

impl ModelAnalytics

pub fn compute_property_correlations(&self) -> PropertyCorrelationMatrix

Compute correlation matrix for model features

Analyzes relationships between different model characteristics using Pearson, Spearman, and Kendall correlation methods from scirs2-stats.

Returns

PropertyCorrelationMatrix containing correlation coefficients and insights

Example

use oxirs_samm::analytics::ModelAnalytics;

let analytics = ModelAnalytics::analyze(&aspect);
let correlations = analytics.compute_property_correlations();

println!("Strong correlations found:");
for insight in &correlations.insights {
    if insight.strength == CorrelationStrength::Strong {
        println!("  {} <-> {}: {:.3}",
                 insight.feature1, insight.feature2, insight.coefficient);
    }
}

impl ModelAnalytics

pub fn compute_spearman_correlations(&self) -> PropertyCorrelationMatrix

Compute Spearman rank correlations between model properties

Spearman correlation is a non-parametric measure of rank correlation. It assesses monotonic relationships between variables without assuming linearity. More robust to outliers than Pearson correlation.

Returns

A correlation matrix with Spearman rank correlation coefficients and insights

Example

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let analytics = ModelAnalytics::from_aspect(aspect)?;
let spearman = analytics.compute_spearman_correlations();

println!("Spearman correlation matrix computed");
println!("Features analyzed: {:?}", spearman.feature_names);
for insight in &spearman.insights {
    println!("  {} <-> {}: {:.3}", insight.feature1, insight.feature2, insight.coefficient);
}

impl ModelAnalytics

pub fn compute_statistical_metrics(&self) -> StatisticalMetrics

Compute advanced statistical metrics for model properties

Uses scirs2-stats to provide comprehensive statistical analysis including dispersion measures, shape statistics, and robustness metrics.

Returns

StatisticalMetrics containing advanced statistics about the model

Example

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let aspect = Aspect::new("urn:samm:org.example:1.0.0#MyAspect".to_string());
let analytics = ModelAnalytics::analyze(&aspect);
let stats = analytics.compute_statistical_metrics();

println!("Coefficient of Variation: {:.2}%", stats.coefficient_variation * 100.0);
println!("Median Absolute Deviation: {:.2}", stats.median_abs_deviation);

pub fn detect_statistical_anomalies(&self) -> Vec<StatisticalAnomaly>

Detect statistical anomalies using robust methods

Uses median absolute deviation (MAD) for robust outlier detection, which is less sensitive to outliers than standard deviation.

Returns

Vector of StatisticalAnomaly indicating unusual patterns

Example

use oxirs_samm::analytics::ModelAnalytics;

let analytics = ModelAnalytics::analyze(&aspect);
let anomalies = analytics.detect_statistical_anomalies();

for anomaly in anomalies {
    println!("⚠ {}: {} (score: {:.2})",
             anomaly.metric_name, anomaly.description, anomaly.deviation_score);
}

pub fn statistical_quality_test(&self) -> QualityTest

Assess model quality using statistical hypothesis testing

Applies statistical tests to determine if the model meets quality thresholds. Uses robust statistical methods from scirs2-stats.

Returns

QualityTest results with statistical confidence levels

Example

use oxirs_samm::analytics::ModelAnalytics;

let analytics = ModelAnalytics::analyze(&aspect);
let test = analytics.statistical_quality_test();

if test.passes_threshold {
    println!("✓ Model meets quality standards (confidence: {:.1}%)",
             test.confidence_level * 100.0);
}

impl ModelAnalytics

pub fn fit_distributions(&self) -> Vec<DistributionFit>

Fit statistical distributions to model metrics

Analyzes the statistical properties of various model metrics and determines which theoretical distribution best fits each metric. This helps understand the underlying nature of model complexity and quality.

Distributions Tested

• Normal: Symmetric, bell-shaped (most common in nature)
• Exponential: Skewed right, memoryless (decay processes)
• Uniform: Equal probability across range (random processes)
• Log-Normal: Skewed right, multiplicative processes

Returns

A vector of fitted distributions for each metric analyzed

Example

use oxirs_samm::analytics::ModelAnalytics;
use oxirs_samm::metamodel::Aspect;

let analytics = ModelAnalytics::analyze(aspect)?;
let fits = analytics.fit_distributions();

for fit in &fits {
    println!("  {} follows {:?} distribution (GoF: {:.3})",
             fit.metric_name, fit.distribution_type, fit.goodness_of_fit);
}

impl ModelAnalytics

pub fn generate_html_report(&self) -> String

Generate HTML report (for visualization)

Trait Implementations

impl Clone for ModelAnalytics

fn clone(&self) -> ModelAnalytics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelAnalytics

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModelAnalytics

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ModelAnalytics

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

where __S: Serializer,

Serialize this value into the given Serde serializer.