Any possibility to add assign arr0s to scalars?

[frjnn]

As the title.

[adamreichold]

I guess you mean in generic context, so that ArrayBase::into_scalar is not helpful?

[frjnn]

It consumes self, something that can't really be done when working with interior mutability.

[bluss]

Any more context, what did you try and what do you want to do? I assume arr0 implements this the same way other dimensionalities do.

[frjnn]

Something like this.

fn main() {
    let mut scalar: f32 = 2.0;

    let zero_dim = ndarray::arr0(3.0);
    scalar += &zero_dim;

    println!("{}", scalar);
}

Out

   Compiling playground v0.0.1 (/playground)
error[E0277]: cannot add-assign `&ArrayBase<OwnedRepr<{float}>, Dim<[usize; 0]>>` to `f32`
 --> src/main.rs:5:12
  |
5 |     scalar += &zero_dim;
  |            ^^ no implementation for `f32 += &ArrayBase<OwnedRepr<{float}>, Dim<[usize; 0]>>`
  |
  = help: the trait `AddAssign<&ArrayBase<OwnedRepr<{float}>, Dim<[usize; 0]>>>` is not implemented for `f32`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` due to previous error

Playground

This code would look a bit less clunky.

// Trains the model.
for epoch in 0..5 {
    let batched_data = dataset.shuffle().batch(2).drop_last();
    let mut total_loss: f32 = 0.0;

    for (input_array, target_array) in batched_data {
        let input = neuronika::from_ndarray(input_array.to_owned());
        let target = neuronika::from_ndarray(target_array.to_owned());

        let result = model.forward(input);

        let loss = loss::mse_loss(result.clone(), target.clone(), loss::Reduction::Mean);
        loss.forward();
        loss.backward(1.0);
        optimizer.step();
        
        total_loss += loss.data().clone().into_scalar(); // total_loss += loss.data() instead,
                                                         // or even total_loss += loss
    }

     println!("Loss for epoch {} : {} ", epoch, total_loss);
}

[adamreichold]

scalar += zero_dim[()];

should work without consuming zero_dim?

[frjnn]

That would also work, but I find it kinda funky.

[bluss]

Using indexing is the consistent way to do it. ndarray prefers using fixed size arrays for indexing in its docs, making scalar += zero_dim[[]] the resulting suggested syntax. This index does not even need bounds checking - it's known statically to be inbounds, the arr0 always has one element, i.e it's low overhead. Consider that data.clone() if data is an arr0 makes a whole new Vec just to contain the array's data, unfortunately.

It would be plausible to improve the situation if needed. The way to get there is to suggest a design for the new feature. I would lean towards using existing functionality. Prefer explicit array -> scalar conversion, either using indexing or other design. Trying to pretend arr0 is a scalar just makes for an impossible long list of traits (interfaces) we need to implement, some of which inevitably conflict with existing array traits. Also, consider if this leaves out dynamic-dimensional zero dimensional arrays - those are even harder to include in those scalar interfaces.

[frjnn]

This is much complete answer. Thank you.