numeric 0.0.6

N-dimensional matrix class for Rust
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


# Numeric Rust

N-dimensional matrix class for Rust 1.0. It links to OpenBLAS and LAPACK to make tensor
operations fast (such as matrix multiplications and linear solvers). It utilizes
Rust's move semantics as much as possible to avoid unnecessary copies.

## Features

Some of the completed and planned features:

* [x] Element-wise addition, subtraction, multiplication, division
* [x] Matrix multiplication and scalar product
* [x] Indexing
* [x] Slicing
* [x] Generic (anything from `Tensor<bool>` to `Tensor<f64>`)
* [x] Mathematical functions
* [x] Linear solver
* [x] Basic random number generation
* [x] Updating slices
* [ ] Strided slices
* [ ] Broadcasted axes
* [ ] Matrix inverse and SVD

## Example

```rust
use numeric::Tensor;

fn main() {
    type T = Tensor<f64>;

    let a = T::range(6).reshaped(&[2, 3]);
    let b = T::new(vec![7.0, 3.0, 2.0, -3.0, 2.0, -5.0]).reshaped(&[2, 3]);
    let c = T::new(vec![7.0, 3.0, 2.0]);

    let d = &a + &b;         // a copy is made
    println!("d = {}", d);

    let e = a.dot(&c);       // matrix multiplication (returns a new tensor)
    println!("e = {}", e);

    let f = a + &b;          // a is moved (no new memory is allocated)
    println!("f = {}", f);

    // Higher-dimensional
    println!("g = {}", T::ones(&[2, 3, 4, 5]));
}
```

Output:

```
d =
 7 4 4
 0 6 0
[Tensor<f64> of shape 2x3]
e =
  7 43
[Tensor<f64> of shape 2]
f =
 7 4 4
 0 6 0
[Tensor<f64> of shape 2x3]
g =
...
[Tensor<f64> of shape 2x3x4x5]
```

## Acknowledgement

Borrowing shamelessly from the great projects Numpy and Torch7.