Struct auto_diff::tensor::gen_tensor::GenTensor

pub struct GenTensor<T> { /* fields omitted */ }

Naive tensor implementation, single thread

Methods

impl<T> GenTensor<T> where
    T: Float, 

pub fn new() -> GenTensor<T>

Creation Ops

pub fn new_raw(data: &[T], shape: &[usize]) -> GenTensor<T>

Create a tensor with given Vec.

pub fn zeros_like(&self) -> GenTensor<T>

pub fn ones_like(&self) -> GenTensor<T>

pub fn empty(shape: &[usize]) -> GenTensor<T>

pub fn fill(d: T, shape: &[usize]) -> GenTensor<T>

Create a tensor filled with the same value d

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);

pub fn stride(&self) -> Vec<usize>

Right dimension changes fastest. Right dimension has the stride 1.

let m1 = GenTensor::<f64>::new_raw(&vec![0.; 3*5*2], &vec![3,5,2]);
assert_eq!(m1.stride(), vec![10,2,1]);

pub fn get(&self, o: &[usize]) -> T

Return value at the index of the tensor.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![2,3]);
assert_eq!(m1.get(&vec![1,1]), 5.);

pub fn get_mut(&mut self, o: &[usize]) -> &mut T

pub fn get_raw(&self) -> Vec<T>

dump the underlying vec

pub fn get_scale(&self) -> T

dump the single value in the tensor if it is the single value in the tensor.

pub fn get_N(&self) -> GenTensor<T>

get NCHW elements, always return the size of left most dimension.

pub fn get_C(&self) -> GenTensor<T>

get NCHW elements, always return the size of second left most dimension.

pub fn get_D(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions.

pub fn get_H(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions or 4 dimensions.

pub fn get_W(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions or 4 dimensions.

pub fn size(&self) -> Vec<usize>

Returns the size of the self tensor.

pub fn numel(&self) -> usize

Returns the total number of elements in the input tensor

pub fn numel_tensor(&self) -> GenTensor<T>

Returns the total number of elements in the input tensor

pub fn sum(&self) -> GenTensor<T>

Returns the sum of all elements.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
assert_eq!(m1.sum().get_scale(), 10.);

pub fn mean(&self, dim: usize, keepdim: bool) -> GenTensor<T>

Returns the mean value of the tensor along dim row.

pub fn unsqueeze(&self, dim: &[usize])

pub fn log1pexp(&self) -> GenTensor<T>

Better log(1 + exp(x)) see https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf

pub fn neg(&self) -> GenTensor<T>

pub fn sigmoid(&self) -> GenTensor<T>

pub fn _right_broadcast<F>(&self, o: &GenTensor<T>, closure: F) -> GenTensor<T> where
    F: Fn(&T, &T) -> T, 

pub fn add(&self, o: &GenTensor<T>) -> GenTensor<T>

element-wise add with right-hand broadcast.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
let m3 = m1.add(&m2);
assert_eq!(m3.get(&vec![0,0]), 2.);
assert_eq!(m3.get(&vec![1,1]), 8.);

pub fn sub(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn mul(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn div(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn mm(&self, o: &GenTensor<T>) -> GenTensor<T>

matrix multiplication

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![2.,3.,4.,5.,6.,7.], &vec![2,3]);
let mut result = m1.mm(&m2);
assert!(result == GenTensor::<f64>::new_raw(&vec![12.,15.,18.,26.,33.,40.,40.,51.,62.,], &vec![3,3]), "");

pub fn matmul(&self, o: &GenTensor<T>) -> GenTensor<T>

matrix multiplication of two tensor

pub fn outer(&self, o: &GenTensor<T>) -> GenTensor<T>

outer product of right-most dimensions.

pub fn squared_error(t1: &Self, t2: &Self) -> GenTensor<T>

pub fn stack(tensors: &[&Self], dim: usize) -> GenTensor<T>

Concatenates sequence of tensors along a new dimension.

All tensors need to be of the same size.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![2.,3.,4.,5.,6.,7.], &vec![3,2]);
let result = GenTensor::<f64>::stack(&vec![&m1, &m2], 1);
let raw = result.get_raw();
for i in raw {
    println!("{}", i);
}
assert_eq!(result.size(), vec![3,2,2]);

pub fn permute(&self, dims: &[usize]) -> GenTensor<T>

Permute the dimensions of this tensor.

let mut m1 = GenTensor::<f64>::fill(1., &vec![2, 3, 5]);
m1.permute(&vec![2, 0, 1]);

pub fn all_close(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn arg_sort(&self, dim: usize, descending: bool) -> GenTensor<T>

pub fn eq_t(&self, o: &GenTensor<T>) -> GenTensor<T>

Computes element-wise equality use eq_t instead, as eq is reserved for == overloading.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
assert_eq!(m1.eq_t(&m2).get(&vec![0,0]), 1.);
assert_eq!(m1.eq_t(&m2).get(&vec![2,1]), 1.);

pub fn equal(&self, o: &GenTensor<T>) -> bool

true if two tensors have the same size and elements, false otherwise.

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
let m2 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
assert_eq!(m1.equal(&m2), true)

pub fn ge(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn gt(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn le(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn lt(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn ne(&self, o: &GenTensor<T>) -> GenTensor<T>

Trait Implementations

impl<T> Clone for GenTensor<T> where
    T: Float, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GenTensor<f32>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for GenTensor<f64>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for GenTensor<f32>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for GenTensor<f64>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> Eq for GenTensor<T> where
    T: Float, 

impl<T> PartialEq<GenTensor<T>> for GenTensor<T> where
    T: Float, 

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
let m2 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
assert_eq!(m1==m2, true)

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.