how to support fixed and Complex<fixed> types.

[mhoffma]

How would one go about adding support for fixed, I'm really new to Rust but I came across this particular library the plotter and evcxr and I haven't been able to put it down. (I guess I caught the rust bug).

I have tried to do some real basic stuff first just using Array<num::Complex<[fixed::types::I1F15>,Ix1> and created some simple arrays no problem got some errors when using with operations and then figured I needed to implement the base traits.

use std::fmt;
use std::ops::{Add,Sub,Mul};
//#[derive(Debug)]
struct Sc16 (Complex<I1F15>);
impl Sc16 {
    fn new(r:f64,i:f64) -> Sc16 {
        Sc16 {
            0:Complex::new(I1F15::from_num(r),I1F15::from_num(i))
        }
    }
    fn exp(&self) -> Sc16 {
        let e = Complex::new(f64::from_fixed(self.0.re),f64::from_fixed(self.0.im)).exp();
        Sc16::new(e.re,e.im)
    }
}
impl fmt::Debug for Sc16 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f,"{}+{}j",&self.0.re,&self.0.im)
    }
}
impl Add for Sc16 {
    type Output = Self;
    fn add(self, other: Self) -> Self {
        Self {
            0: Complex::new( self.0.re.saturating_add(other.0.re), 
                             self.0.im.saturating_add(other.0.im)
            )
        }
    }
}
impl Sub for Sc16 {
    type Output = Self;
    fn sub(self, other: Self) -> Self {
        Self {
            0: Complex::new( self.0.re.saturating_sub(other.0.re), 
                             self.0.im.saturating_sub(other.0.im)
            )
        }
    }
}
impl Mul for Sc16 {
    type Output = Self;
    fn mul(self, other: Self) -> Self {
        let a = self.0.re;
        let b = self.0.im;
        let c = other.0.re;
        let d = other.0.im;
        
        Self { 
            0: Complex::new( a.wide_mul(b).saturating_sub(b.wide_mul(d)).to_fixed::<I1F15>(), 
                             a.wide_mul(d).saturating_add(b.wide_mul(c)).to_fixed::<I1F15>()
            )
        }
    }
}

so then I can take some signal which I have in the variable 'o' and convert it to its fixed representation.

let b=(max.abs()+min.abs());
let c :Array<Sc16,Ix1>= o.map(|x| Sc16::new(x.re/b,x.im/b));

now 'c' has exactly what I expected.

[0.41003+0.1025j, 0.41068+0.10187j, 0.4113+0.10126j, 0.41193+0.10062j, 0.41254+0.09998j, ..., 0.4069+0.1056j, 0.4075+0.10498j, 0.40814+0.10437j, 0.40878+0.10376j, 0.4094+0.10315j], shape=[4096], strides=[1], layout=CFcf (0xf), const ndim=1

ok I wanted to just do something simple like element wise + or * but I get this error what is missing?

&c+c

[E0369] Error: cannot add `ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>` to `&ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>`
   ╭─[command_185:1:1]
   │
 1 │ &c+c
   · ─┬┬┬  
   ·  ╰──── &ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>
   ·   ││  
   ·   ╰─── error: cannot add `ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>` to `&ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>`
   ·    │  
   ·    ╰── ndarray::ArrayBase<OwnedRepr<Sc16>, ndarray::Dim<[usize; 1]>>
───╯

Any useful direction to set me off on would be great...

[jturner314]

You're on the right track but are missing just a couple of small things. The Add impl you're trying to use is documented here; it has the signature:

impl<'a, A, B, S, S2, D, E> Add<ArrayBase<S2, E>> for &'a ArrayBase<S, D>
where
    A: Clone + Add<B, Output = B>,
    B: Clone,
    S: Data<Elem = A>,
    S2: DataOwned<Elem = B> + DataMut,
    D: Dimension,
    E: Dimension + DimMax<D>,

The arrays' element types in this signature are A and B. The impl requires that A: Clone and B: Clone. In your case, the element type is Sc16, so you need to implement Clone for that type. You can do so by adding #[derive(Clone)], like this:

#[derive(Clone)]
struct Sc16(Complex<I1F15>);

After that change, however, you'll get a new error:

error[E0505]: cannot move out of `c` because it is borrowed
  --> src/main.rs:54:10
   |
54 |     &c + c;
   |     --   ^ move out of `c` occurs here
   |     |
   |     borrow of `c` occurs here

The line &c + c translates into Add::add(&c, c). You can't move c and borrow it at the same time. (The borrow checker enforces this.) To instead allocate a new array for the result, you can use &c + &c instead. (This uses a different impl, documented here.)

You might find this section of the docs on arithmetic operations useful.

[mhoffma]

can I somehow use these to define all of those special missing pieces?

impl_scalar_lhs_op!(Sc16, Commute, +, Add, add, "addition");
impl_scalar_lhs_op!(Sc16, Ordered, -, Sub, sub, "subtraction");
impl_scalar_lhs_op!(Sc16, Commute, *, Mul, mul, "multiplication");
//impl_scalar_lhs_op!(Sc16, Ordered, /, Div, div, "division");

Because now I get the complaint about ScalarOperand and it looks as if you have pretty amazing circuitry here I just want to reuse your macro...

   Compiling cmplx v0.1.0 (/home/marc/rs/cmplx)
error[E0277]: the trait bound `cmplx::Sc16: ScalarOperand` is not satisfied
   --> src/cmplx.rs:141:19
    |
141 |         let d = a * b;
    |                   ^ the trait `ScalarOperand` is not implemented for `cmplx::Sc16`
    |
    = help: the following other types implement trait `ScalarOperand`:
              bool
              f32
              f64
              i128
              i16
              i32
              i64
              i8
            and 9 others
    = note: required for `ArrayBase<OwnedRepr<cmplx::Sc16>, Dim<[usize; 1]>>` to implement `Mul<cmplx::Sc16>`

when I try to multiply an vector by an Sc16 scalar.

[jturner314]

The impl_scalar_ls_op macro is not exported as part of the public API, but you could copy the definition of the macro (and the if_commutative macro it depends on) into your project so that you could use it.

As you mentioned, you probably also want to implement ScalarOperand, like this:

impl ScalarOperand for Sc16 {}

(The body of the impl is empty, since the trait has no members. ScalarOperand is just used as a marker for trait for types which are considered scalars.)

[mhoffma]

this worked like a charm!!!!

Thank you is it possible to request the exposure of that impl_scalar_ls_op so I don't need to include it in my module in the future?