Views and operations with mixed scalar types

[jedbrown]

I'm curious about the feasibility of extending ndarray to support mixed-precision and mixed-domain algorithms. I was thinking of syntax something like this, enabling a view to offer up f64 values despite the backing storage being f32 (for example).

    let a: Array1<f64> = array![1., 2., 3.];
    let b: Array1<f32> = array![4., 5., 6.];
    let c = a + b.view_as::<f64>();

I'm a Rust novice and ran into some trouble (attempting to use associated_type_defaults to avoid more disruptive changes)

 pub unsafe trait RawData: Sized {
     /// The array element type.
    type Elem: From<Self::ElemMem>;
    type ElemMem;

where ArrayBase would have

    ptr: std::ptr::NonNull<S::ElemMem>,

and the Index implementation becomes

     fn index(&self, index: I) -> &S::Elem {
         debug_bounds_check!(self, index);
         unsafe {
            &S::Elem::from(*self.ptr.as_ptr().offset(
                 index
                     .index_checked(&self.dim, &self.strides)
                    .unwrap_or_else(|| array_out_of_bounds())
            ))
         }
     }

I'm curious whether

1. this sort of feature to support mixed precision is of interest to include in ndarray, and
2. this implementation strategy seems like a reasonable way to go about it.

[bluss]

A regular array view is like a memory view, so it's not possible at this time to have element access that is this abstract (where the produced element would be of different type than what's stored in memory).

[jedbrown]

Thanks. Is mixed precision arithmetic something that you would consider out-of-scope for ndarray, or just not a priority at this time?

[bluss]

mixed precision seems interesting, what's your use case? But I don't think using views in this way is the way to get there - not in ndarray. That's why the use case is interesting, so we find a way there.

[jedbrown]

An example of my interest is reducing the precision of a preconditioner (or parts of a preconditioner, such as a multigrid cycle) for Krylov methods. In the direct solver world, they sometimes compute a factorization in reduced precision and use "iterative refinement" (Richardson or Krylov) to get a full accuracy result. BLIS (a blas-src implementation since 0.7) has very expressive mixed precision/mixed domain support (docs and paper) and I'd love to get that sort of capability behind a safe rusty interface (whether dispatching to BLIS or not).