Common Functions

We will improve further for this part

Current RSTSR implements many common functions, and that can cover lots of common usage as a tensor algebra library. However, there are still many features that has not implemented.

1. Elementwise Functions

For RSTSR, most functions declared in Python Array API has been implemented. Most of them can be called as regular rust function, or as associated methods:

#[rustfmt::skip]
let a = rt::asarray(vec![
    5., 2.,
    3., 6.,
    1., 8.,
]).into_shape([3, 2]);
let b = rt::asarray(vec![3., 4.]);

// broadcasted comparison a >= b
// called by associated method
let c = a.greater_equal(&b);

println!("{:5}", c);
// output:
// [[ True False]
//  [ True  True]
//  [False  True]]

// sine of b
// called by function
let d = rt::sin(&b);

println!("{:6.3}", d);
// output: [  0.141 -0.757]

Note that some exceptions that can only called by associated methods tensor.method(...), and cannot be called as regular rust functions rt::method(tensor, ...) currently. These exceptions includes

• unary functions .abs(), .real(), .imag(), .sign();
• binary function .pow().

Consequently, for example .abs(), following code is valid:

use num::complex::c64;

let a = rt::linspace((c64(1., 2.), c64(-3., 4.), 3));

// `.abs()` can only called by associated method currently
let c = a.abs();
println!("{:8.3}", c);
// output: [    2.236    3.162    5.000]

However, RSTSR does not have abs function.

As a take home message, if not sure how to use elementwise functions, use the associated tensor.method(...).

    rt::abs(&a) // RSTSR does not have `abs` as function

    // This is due to different implementation for real and complex numbers.
    // For real types, both `abs(&a)` and `abs(a)` works; latter one is inplace absolute;
    // - implemented trait TensorRealAbsAPI
    // For complex types, only `abs(&a)` works.
    // - implemented trait TensorComplexAbsAPI

2. Mapping Functions