Numpy to rust-ndarray docs error.

[dineshadepu]

Hi,

I am trying the example code given in docs. I tried zeros example.

    let foo = Array::zeros((3, 2, 4).f());

Which gave me an error

error[E0283]: type annotations required: cannot resolve `_: std::clone::Clone`
 --> src/main.rs:8:15
  |
8 |     let foo = Array::zeros((3, 2, 4).f());
  |               ^^^^^^^^^^^^
  |
  = note: required by `ndarray::impl_constructors::<impl ndarray::ArrayBase<S, D>>::zeros`

Am I doing it right ?

[dineshadepu]

Even the np.zeros_like function gives the same error

let a = Array::linspace(0., 1., 10);
    let foo = Array::zeros(a.raw_dim());

error[E0283]: type annotations required: cannot resolve `_: std::clone::Clone`
 --> src/main.rs:9:15
  |
9 |     let foo = Array::zeros(a.raw_dim());
  |               ^^^^^^^^^^^^
  |
  = note: required by `ndarray::impl_constructors::<impl ndarray::ArrayBase<S, D>>::zeros`

error: aborting due to previous error

[rcarson3]

So, this error seems to be implying that the Rust compiler can't infer what type the Array should be. The compiler can sometimes figure this out on its own depending on how you use the variable later on in the program or function.

You can rectify this by using the turbofish operator to provide the necessary type annotation to tell the compile what type the Array variable should be. I've provided an example down below.

edit: See @jturner314 comment below for further clarification. My original comment left out the dimensionality type that goes with Array.

let foo = Array::<f64>::zeros((3, 2, 4).f());

You can change <f64> to one of the other supported types for Array as well.

[jturner314]

Thanks @rcarson3. Yeah, the issue is that the compiler is not able to infer the element type in this case. Most of the time, you don't have to specify the element type because the compiler can infer it from usage.

A minor correction: Array has two type parameters (the element type and the dimensionality), so to specify just the element type, you'd use let foo = Array::<f64, _>::zeros((3, 2, 4).f()); (using _ to infer the dimensionality).

All of the following work:

// This is an example where the compiler can infer the element type
// because `f64::sin` can only be called on `f64` elements:
let arr1 = Array::zeros((3, 2, 4).f());
arr1.mapv(f64::sin);

// Specify just the element type and infer the dimensionality:
let arr2 = Array::<f64, _>::zeros((3, 2, 4).f());
let arr3: Array<f64, _> = Array::zeros((3, 2, 4).f());

// Specify both the element type and dimensionality:
let arr4 = Array3::<f64>::zeros((3, 2, 4).f());
let arr5: Array3<f64> = Array::zeros((3, 2, 4).f());
let arr6 = Array::<f64, Ix3>::zeros((3, 2, 4).f());
let arr7: Array<f64, Ix3> = Array::zeros((3, 2, 4).f());

[rcarson3]

@jturner314 Okay cool didn't realize there was a second type parameter associated with Array though now thinking about it that makes sense. I guess I've been using more of the specified dimension Array types, so I haven't had the compiler get mad at me for leaving out that extra parameter. I'll edit my original comment to make note of that.

[jturner314]

This issue seems to be resolved by #432, so I'm closing it. If there's anything else, please feel free to reopen it.