rustygraph 0.4.2

A high-performance library for visibility graph computation from time series data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Weighted visibility graph example.
//!
//! This example demonstrates how to create weighted visibility graphs
//! with custom edge weight functions.

use rustygraph::algorithms::{visibility_weighted, VisibilityType};
use rustygraph::TimeSeries;

fn main() {
    println!("=== RustyGraph Weighted Graphs Example ===\n");

    let series = TimeSeries::from_raw(vec![1.0, 3.0, 2.0, 4.0, 1.0]).unwrap();

    // Example 1: Natural visibility with value difference weights
    println!("1. Natural visibility - Value difference weights:");
    let edges = visibility_weighted(&series, VisibilityType::Natural, |_, _, vi: f64, vj: f64| {
        (vj - vi).abs()
    });

    for ((src, dst), weight) in &edges {
        println!("  {} -> {} : weight = {:.2}", src, dst, weight);
    }

    // Example 2: Natural visibility with temporal distance weights
    println!("\n2. Natural visibility - Temporal distance weights:");
    let edges = visibility_weighted(&series, VisibilityType::Natural, |i, j, _, _| {
        (j - i) as f64
    });

    for ((src, dst), weight) in &edges {
        println!("  {} -> {} : weight = {:.0}", src, dst, weight);
    }

    // Example 3: Horizontal visibility with geometric mean weights
    println!("\n3. Horizontal visibility - Geometric mean weights:");
    let edges = visibility_weighted(&series, VisibilityType::Horizontal, |_, _, vi: f64, vj: f64| {
        (vi * vj).sqrt()
    });

    for ((src, dst), weight) in &edges {
        println!("  {} -> {} : weight = {:.2}", src, dst, weight);
    }

    // Example 4: Custom complex weight function
    println!("\n4. Custom weight function (normalized difference):");
    let max_val = series.values.iter().filter_map(|&v| v).fold(f64::NEG_INFINITY, |a, b| a.max(b.into()));
    let min_val = series.values.iter().filter_map(|&v| v).fold(f64::INFINITY, |a, b| a.min(b.into()));
    let range = max_val - min_val;

    let edges = visibility_weighted(&series, VisibilityType::Natural, |_, _, vi: f64, vj: f64| {
        if range > 0.0 {
            (vj - vi).abs() / range
        } else {
            0.0
        }
    });

    for ((src, dst), weight) in &edges {
        println!("  {} -> {} : weight = {:.3}", src, dst, weight);
    }

    // Example 5: Constant weights (equivalent to unweighted)
    println!("\n5. Constant weights (unweighted equivalent):");
    let edges = visibility_weighted(&series, VisibilityType::Horizontal, |_, _, _, _| 1.0);

    println!("  All edges have weight 1.0");
    println!("  Total edges: {}", edges.len());
}