acme-tensor 0.3.1

A comprehensive tensor library for Rust with support for automatic-differentiation.
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

/*
    Appellation: iter <test>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
#![cfg(test)]
extern crate acme_tensor as acme;

use acme::create::Linspace;
use acme::prelude::{IntoShape, Layout, Shape, Tensor};
use num::traits::{FromPrimitive, Num};

fn linvec<T>(n: usize) -> (Vec<T>, usize)
where
    T: Copy + Default + FromPrimitive + Num + PartialOrd,
{
    let space = Vec::linspace(T::zero(), T::from_usize(n).unwrap(), n);
    (space, n)
}

#[test]
fn test_layout_iter() {
    let shape = (2, 2).into_shape();
    let layout = Layout::contiguous(shape);
    let exp = [vec![0usize, 0], vec![0, 1], vec![1, 0], vec![1, 1]];
    for (pos, exp) in layout.iter().zip(exp.iter()) {
        assert_eq!(pos.position(), *exp);
    }
    for (pos, exp) in layout.iter().rev().zip(exp.iter().rev()) {
        assert_eq!(pos.position(), *exp);
    }
}

#[test]
fn test_iter() {
    let shape = Shape::from_iter([2, 2, 2, 2]);
    let (exp, n) = linvec::<f64>(shape.size());
    let tensor = Tensor::linspace(0f64, n as f64, n)
        .reshape(shape.clone())
        .unwrap();
    assert_eq!(&tensor, &exp);

    let mut tensor = Tensor::zeros(shape);
    for (elem, val) in tensor.iter_mut().zip(exp.iter()) {
        *elem = *val;
    }
    assert_eq!(&tensor, &exp);
}
#[test]
fn test_iter_scalar() {
    let exp = 10f64;
    let tensor = Tensor::from_scalar(exp);
    let mut iter = tensor.iter();
    assert_eq!(iter.next(), Some(&exp));
    assert_eq!(iter.next(), None);
}

#[test]
fn test_iter_mut_rev() {
    let shape = Shape::from_iter([2, 2, 2, 2]);
    let n = shape.size();
    let exp = Vec::linspace(0f64, n as f64, n);
    let rev = exp.iter().rev().copied().collect::<Vec<f64>>();
    let mut tensor = Tensor::zeros(shape);
    for (elem, val) in tensor.iter_mut().rev().zip(exp.iter()) {
        *elem = *val;
    }
    assert_eq!(&tensor, &rev);
}

#[test]
fn test_iter_rev() {
    let shape = Shape::from_iter([2, 2]);
    let n = shape.size();
    let exp = Vec::linspace(0f64, n as f64, n);
    let tensor = Tensor::linspace(0f64, n as f64, n).reshape(shape).unwrap();

    for (i, j) in tensor.iter().rev().zip(exp.iter().rev()) {
        assert_eq!(i, j);
    }
}

#[test]
fn test_sum() {
    let shape = (2, 2).into_shape();
    let a = Tensor::fill(shape, 1f64);
    assert_eq!(a.sum(), 4.0);
}

#[test]
fn test_product() {
    let shape = (2, 2).into_shape();
    let a = Tensor::fill(shape, 2f64);
    assert_eq!(a.product(), 16.0);
}