source: doc/theses/mike_brooks_MMath/tests/arrays.rs@ c8bdbaf

use std::convert::TryInto;
use std::convert::TryFrom;
fn main() {
        // typed/size/repeat initialization
        let val = 42;
        let mut ia: [usize; 5] = [val; 5];

        // typed/size/individual initialization
        let fval = 42.2;
        let fa: [f64; 5] = [1.2, fval, 5.6, 7.3, 9.1];

        // enumerating range/type
        for i in 0..ia.len() { print!("{:?} ", ia[i] ); } println!("");  // 42 42 42
        for fv in fa { print!("{:?} ", fv ); } println!("");  // 1.2 42.2 5.6
        for i in 0..=1 { ia[i] = i; }    // mutable changes
        for iv in ia { print!("{:?} ", iv ); } println!("");  // 0 1 42

        // 2 dimensional (matrix), fixed-size
        const ROWS: usize = 4;
        const COLS: usize = 6;
        let mut fmatrix: [[f64; COLS]; ROWS] = [[0.; COLS]; ROWS];
        for r in 0 .. ROWS {
                for c in 0 .. COLS {
                        fmatrix[r][c] = r as f64 + c as f64;
                }
                println!( "{:?}", fmatrix[r] );
        }
        
        let mut slice2: &[f64] = &fmatrix[3][2 ..= 4];
        println!( "{:?}", slice2 );
        slice2 = &fmatrix[1 ..= 3][1];
        println!( "{:?}", slice2 );

        // implicit type/size, print entire array and length
        println!( "{:?} {:?}", ia, ia.len() );
        ia = [5; 5];
        println!( "{:?} {:?}", ia, ia.len() );
        ia = [1, 2, 3, 4, 5];
        println!( "{:?} {:?}", ia, ia.len() );

        // array copy
        let ia2: [usize; 5];
        ia2 = ia;
        println!( "copy = {:?} ", ia2 ); // 0 1 42 

        let mut numbers = [1, 2, 3, 4, 5];
        // pass array by value
        fn update1( mut arr:[i32; 5] ) {
                for i in 0 .. arr.len() { arr[i] = 0; }
                println!( "function update {:?}", arr );
        }
        update1( numbers );

        // pass array by reference
        fn update2( arr: & mut [i32; 5] ) {
                for i in 0 .. arr.len() { arr[i] = 0; }
                println!( "function update {:?}", arr );
        }
        update2( &mut numbers );

        // slice is barrowing a subset of an array, dimension bounds can be expressions
        println!( "slice {:?}", &ia[0..3] ); // fixed bounds, [1, 2, 3]
        println!( "slice {:?}", &ia[ia.len() - 2 .. ia.len()] ); // variable bounds, [4, 5]
        println!( "slice {:?}", &ia[ia.len() - 2 .. ] ); // drop upper bound, [4, 5]
        println!( "slice {:?}", &ia[.. ia.len() - 2 ] ); // drop lower bound, [1, 2, 3]
        println!( "slice {:?}", &ia[..] ); // drop both bound, [1, 2, 3, 4, 5]

        let slice: &[f64];
        slice = &fa[0 ..= 1];
        println!( "slice = {:?}", slice ); // [1.2, 42.2]
        let mut fa2: [f64; 2] = <[f64; 2]>::try_from( slice ).unwrap(); // convert slice to array
        println!( "fa2 {:?}", fa2 ); // [1.2, 42.2]
        fa2 = (& fa[2 ..= 3]).try_into().unwrap(); // convert slice to array
        println!( "fa2 {:?}", fa2 ); // [1.2, 42.2]

        // pass (all) slice by reference
        fn zero( arr: & mut [usize] ){
                for i in 0 .. arr.len() { arr[i] = 0; }
                println!( "function update {:?}", arr );
        }
        zero( & mut ia[0..5] );
        zero( & mut ia[0..3] );

        let mut vec: Vec< Vec<usize> > = Vec::new();
        for r in 0 .. ROWS {
                let mut row: Vec<usize> = Vec::new();
                for c in 0 .. COLS {
                        row.push(r + c);
                }
                vec.push(row);
        }
        for r in 0 .. 4 {
                for c in 0 .. 4 {
                        print!("{} ", vec[r][c]);
                }
                println!("");
        }

        // 2 dimensional (matrix), variable-size (C++ vector) array of array, heap allocated
        let (rows, cols) = (4, 6);
        let mut matrix = vec![vec![0; cols]; rows];
        for r in 0 .. rows {
                for c in 0 .. cols {
                        matrix[r][c] = r + c;
                        print!("{} ", matrix[r][c]);
                }
                println!("");
        }

        let mut slice3: &[usize] = &matrix[3][2 ..= 4];
        println!( "{:?}", slice3 );
        slice3 = &matrix[1 ..= 3][1];
        println!( "{:?}", slice3 );

        fn f<const N: usize>( arg: [usize; N] ) {
                for r in 0 .. arg.len() {
                        print!( "{} ", arg[r] );
                }
                println!("");
        }
        f( ia );
}

// Local Variables: //
// tab-width: 4 //
// compile-command: "rustc arrays.rs" //
// End: //