ohsl 0.12.0

A collection of numerical routines and mathematical types for use in scientific computing.
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
126

// cargo run --example vector_algebra

extern crate ohsl;

pub use ohsl::vector::{Vector, Vec64};
pub use ohsl::constant::*;

use std::time::{Instant, Duration};

fn main() {
    println!("----- Vector algebra -----");

    // Create a filled vector of specified size
    let mut a = Vec64::new( 4, 0.0 ); 
    a[ 0 ] = 1.0; a[ 1 ] = 3.0; a[ 2 ] = 1.0; a[ 3 ] = - 1.0;
    println!("  * a = {}", a.clone() );
    
    // Create a vector from a standard vec
    let mut b = Vector::<f64>::create( vec![ 2.0, 1.0, 3.0, 4.0 ] );
    println!("  * b = {}", b.clone() );

    // Create an empty vector of unspecified size
    let mut c = Vec64::empty();
    println!("  * c = {}", c );

    // Do some basic algebra
    c = a.clone() + b.clone();
    println!( "  * c = a + b = {}", c );
    c = b.clone() - a.clone();
    println!( "  * c = b - a = {}", c );
    c = 3.0 * a.clone();
    println!( "  * c = 3 * a = {}", c );
    c = a.clone() / 3.0;
    println!( "  * c = a / 3 = {}", c );

    // Add some new elements and swap them around
    a.push( 2.0 );
    b.resize( 5 );
    b[ 4 ] = - 3.0;
    b.swap( 3, 4 );
    println!("  * a = {}", a );
    println!("  * b = {}", b );

    // Remove elements 
    a.pop();
    a.pop();
    b.resize( 3 );
    println!( "  * a = {}", a );
    println!( "  * b = {}", b );

    // Magnitude of the vectors 
    println!( "  * |a| = {}", a.norm_2() );
    println!( "  * |b| = {}", b.norm_p( 2.0 ) );

    // Angle between the two vectors
    let cos: f64 = a.dot( &b ) / ( a.norm_2() * b.norm_2() );
    let rad = f64::acos( cos );
    let deg = rad * 180.0 / PI;
    println!( "  * angle between a and b = {} degrees", deg );

    // Create vectors of spaced elements
    let a = Vec64::linspace( 0.0, 1.0, 5 );
    let b = Vec64::powspace( 0.0, 1.0, 5, 1.5 );
    println!( "  * Linearly spaced elements = {}", a );
    println!( "  * Power law spaced elements (p=1.5) = {}", b );

    // Test vector dot product parallel performance
    println!( "  * i \t n=2^i \t\t time seq \t time par \t speedup \t time mixed \t speedup" );
    let num_runs = 100;
    for i in 8..18 {
        let n: usize = 2usize.pow(i);
        let t_seq = dot_seq_avg( n, num_runs );
        let t_par = dot_par_avg( n, num_runs );
        let t_mixed = dot_mixed_avg( n, num_runs );
        let speedup_par = t_seq.as_secs_f64() / t_par.as_secs_f64();
        let speedup_mixed = t_seq.as_secs_f64() / t_mixed.as_secs_f64();
        println!( "  * {} \t {:0>6} \t {:.2?} \t {:.2?} \t {:.6} \t {:.2?} \t {:.6}",
                    i, n, t_seq, t_par, speedup_par, t_mixed, speedup_mixed );
    }
    //TODO it would be cool to have an Option for Sequential/Parallel/Mixed in the dot function and
    //places it is used.
    println!( "--- FINISHED ---" );
}

fn dot_seq_avg( n: usize, num_runs: u32 ) -> Duration {
    let mut sum = Duration::ZERO;
    for _ in 0..num_runs {
        let x = Vec64::random( n );
        let y = Vec64::random( n );
        let now = Instant::now();
        let _dot_seq = x.dot( &y );
        let t_seq = now.elapsed();
        sum += t_seq;
    }
    sum / num_runs
}

fn dot_par_avg( n: usize, num_runs: u32 ) -> Duration {
    let mut sum = Duration::ZERO;
    for _ in 0..num_runs {
        let x = Vec64::random( n );
        let y = Vec64::random( n );
        let now = Instant::now();
        let _dot_par = x.dot_f64( &y );
        let t_par = now.elapsed();
        sum += t_par;
    }
    sum / num_runs
}

fn dot_mixed_avg( n: usize, num_runs: u32 ) -> Duration {
    let mut sum = Duration::ZERO;
    for _ in 0..num_runs {
        let x = Vec64::random( n );
        let y = Vec64::random( n );
        let now = Instant::now();
        if n < 2usize.pow(15) {
            let _dot_seq = x.dot( &y );
        } else {
            let _dot_par = x.dot_f64( &y );
        }
        let t_mixed = now.elapsed();
        sum += t_mixed;
    }
    sum / num_runs
}