numrs2 0.3.1

A Rust implementation inspired by NumPy for numerical computing (NumRS2)
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Basic Distributed Computing Example for NumRS2
//!
//! This example demonstrates the fundamental concepts of distributed computing
//! in NumRS2, including process initialization, distributed arrays, and collective
//! operations.
//!
//! # Running the Example
//!
//! To run this example with multiple processes, set environment variables:
//!
//! Terminal 1 (Process 0 - Master):
//! ```bash
//! NUMRS2_RANK=0 NUMRS2_SIZE=2 NUMRS2_MASTER_ADDR=127.0.0.1:5000 cargo run --example distributed_basics --features distributed
//! ```
//!
//! Terminal 2 (Process 1):
//! ```bash
//! NUMRS2_RANK=1 NUMRS2_SIZE=2 NUMRS2_MASTER_ADDR=127.0.0.1:5000 cargo run --example distributed_basics --features distributed
//! ```

#[cfg(feature = "distributed")]
use numrs2::distributed::prelude::*;

#[cfg(feature = "distributed")]
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("NumRS2 Distributed Computing - Basic Example");
    println!("============================================\n");

    // Initialize distributed environment
    println!("Initializing distributed environment...");
    let world = init().await?;

    let rank = world.rank();
    let size = world.size();

    println!("✓ Process {} of {} initialized successfully", rank, size);
    println!("  Hostname: {}", world.process_info().hostname);
    println!("  Address: {}\n", world.process_info().addr);

    // Demonstrate process information
    println!("Process Information:");
    println!("  Rank: {}", rank);
    println!("  Size: {}", size);
    println!("  Is root: {}\n", world.is_root());

    // Create local data
    println!("Creating local data...");
    let local_data: Vec<f64> = (0..10).map(|i| (rank * 10 + i) as f64).collect();
    println!("  Local data (rank {}): {:?}\n", rank, &local_data[..5]);

    // Demonstrate distributed array
    println!("Creating distributed array...");
    let global_size = size * 10;
    let dist_array = DistributedArray::from_local(
        local_data.clone(),
        DistributionStrategy::Block,
        global_size,
        &world,
    )?;

    println!("✓ Distributed array created");
    println!("  Global size: {}", dist_array.global_size());
    println!(
        "  Local size (rank {}): {}\n",
        rank,
        dist_array.local_size()
    );

    // Demonstrate index conversion
    if rank == 0 {
        println!("Index Conversion Examples:");
        let global_idx = GlobalIndex::new(15);
        println!("  Global index 15:");

        match dist_array.global_to_local(&global_idx)? {
            Some(local_idx) => {
                println!("    → Local index: {} (on this process)", local_idx.index());
            }
            None => {
                println!("    → Not owned by this process");
            }
        }

        let local_idx = LocalIndex::new(5);
        let global = dist_array.local_to_global(&local_idx)?;
        println!("  Local index 5 → Global index: {}\n", global.index());
    }

    // Barrier synchronization
    println!("Synchronizing at barrier...");
    barrier(&world).await?;
    println!("✓ All processes reached barrier\n");

    // Demonstrate process group information
    if world.is_root() {
        println!("Process Group Information:");
        println!("  Total processes: {}", world.group().size());
        println!("  Ranks: {:?}\n", world.group().ranks);
    }

    // Another barrier before finalization
    barrier(&world).await?;

    // Finalize distributed environment
    if world.is_root() {
        println!("\nFinalizing distributed environment...");
    }

    finalize(world).await?;

    if rank == 0 {
        println!("✓ Distributed environment finalized successfully");
        println!("\nExample completed successfully! 🎉");
    }

    Ok(())
}

#[cfg(not(feature = "distributed"))]
fn main() {
    eprintln!("This example requires the 'distributed' feature.");
    eprintln!("Run with: cargo run --example distributed_basics --features distributed");
    std::process::exit(1);
}