tension 0.0.2

Tensor library with OpenCL acceleration
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

use std::{
    slice,
};
use crate::{
    Prm,
    Tensor, HostTensor,
};

/// Iterator over host tensor content.
pub struct HostTensorIter<'a, T: Prm> {
    tensor: &'a HostTensor<T>,
    position: Vec<usize>,
    first: bool,
    exhausted: bool,
}

/// Mutable iterator over host tensor content.
pub type HostTensorIterMut<'a, T> = slice::IterMut<'a, T>;

impl <'a, T: Prm> HostTensorIter<'a, T> {
    /// Create iterator over specified tensor.
    pub(crate) fn new(tensor: &'a HostTensor<T>) -> Self {
        let mut position = Vec::<usize>::new();
        position.resize(tensor.shape().len(), 0);
        Self {
            tensor,
            position,
            first: true,
            exhausted: false,
        }
    }

    fn next_position(&mut self) -> Option<&[usize]> {
        let shape = self.tensor.shape();
        if self.exhausted {
            None
        } else if self.first {
            if shape.content() > 0 {
                self.first = false;
                Some(self.position.as_slice())
            } else {
                self.exhausted = true;
                None
            }
        } else {
            let mut carry = true;
            for i in 0..shape.len() {
                if carry {
                    carry = false;
                    let mut pos = self.position[i] + 1;
                    if pos >= shape[i] {
                        pos = 0;
                        carry = true;
                    }
                    self.position[i] = pos;
                }
            }
            if carry {
                self.exhausted = true;
                None
            } else {
                Some(self.position.as_slice())
            }
        }
    }

    fn next_index(&mut self) -> Option<usize> {
        let shape = self.tensor.shape().clone();
        self.next_position().map(|slice| {
            slice.iter().zip(shape.iter())
            .fold((1, 0), |(stride, pos), (x, len)| {
                (stride*len, pos + stride*x)
            }).1
        })
    }
}

impl<'a, T: Prm> Iterator for HostTensorIter<'a, T> {
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        self.next_index()
        .map(|pos| &self.tensor.buffer().as_slice()[pos])
    }
}