numeric 0.0.4

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


# Numeric Rust

N-dimensional matrix class for Rust 1.0. It links to OpenBLAS to make tensor
operations fast (like matrix multipliations). 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
* [ ] Strided slices
* [ ] Updating slices
* [ ] Broadcasted axes
* [ ] Matrix solver / inverse

## Example

```rust
use numeric::DoubleTensor;

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

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

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

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

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

Output:

```
d =
[[  7.00   4.00   4.00]
 [  0.00   6.00   0.00]]
e =
[  7.00  43.00]
f =
[[  7.00   4.00   4.00]
 [  0.00   6.00   0.00]]
g =
DoubleTensor([2, 3, 4, 5])    
```