Can numpy.net convert ndarray to Array type?

If ndarray has N dimensions, it will be very troublesome to restore it to T[,]. Maybe numpy.net can use implicit operators to convert ndarray to Array type. https://learn.microsoft.com/en-us/dotnet/api/system.array?view=net-7.0 https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/user-defined-conversion-operators

This way I can easily convert ndarray to torch.tensor🤣 https://github.com/dotnet/TorchSharp/blob/c55e9f535aa46c4dfa104d839019553b693616c0/src/TorchSharp/Tensor/Tensor.Factories.cs#L2654

int[,,] a = new int[3, 5, 7];
Array b = a;
Tensor c = as_tensor(b);
Console.WriteLine(c);

// [3x5x7], type = Int32, device = cpu

[KevinBaselinesw]

I figured out how to use your sample function. It does eliminate several hundred lines of redundant code. See it in the new release.

thank you!

[KevinBaselinesw]

I did not get an email on this comment like I usually do. It is lucky that I checked these boards this morning.

Internally, Numpy stores all arrays as single dimension arrays. When you add a shape to it, you are just adjusting some internal values that make it appear to be multi-dimensional.

Are you suggesting that we add something like this to the library? It would have to be expanded to include all 16 datatypes. If we make it work for 5 dimensions, that is 64 separate explicit operators.

Can you think of an easier way to do this?

  public static explicit operator int[,](ndarray nd)
      {
          if (nd.ndim != 2)
              throw new Exception("ndarray does not have 2 dimensions");

          // todo: convert nd to int[,] array

          return new int[,] { { 0 }, { 1 } };
      }

      public static explicit operator int[,,] (ndarray nd)
      {
          if (nd.ndim != 3)
              throw new Exception("ndarray does not have 3 dimensions");

          // todo: convert nd to int[,,] array

          return new int[,,] { { { 1, 2 }, { 3, 4 }, { 5, 6 } } };
      }

      public static explicit operator int[,,,] (ndarray nd)
      {
          if (nd.ndim != 4)
              throw new Exception("ndarray does not have 4 dimensions");

          // todo: convert nd to int[,,,] array

          return new int[,,,] { { { { 1, 2 }, { 3, 4 }, { 5, 6 } } } };
      }

      public static explicit operator double[,,,] (ndarray nd)
      {
          if (nd.ndim != 4)
              throw new Exception("ndarray does not have 4 dimensions");

          // todo: convert nd to double[,,,] array

          return new double[,,,] { { { { 1, 2 }, { 3, 4 }, { 5, 6 } } } };
      }

      public static explicit operator System.Numerics.Complex[,,,] (ndarray nd)
      {
          if (nd.ndim != 4)
              throw new Exception("ndarray does not have 4 dimensions");

          // todo: convert nd to System.Numerics.Complex[,,,] array

          return new System.Numerics.Complex[,,,] { { { { 1, 2 }, { 3, 4 }, { 5, 6 } } } };
      }

The code to call them would look like this:

  [TestMethod]
      public void test_AsMultiDimension()
      {
          ndarray a = np.array(new int[,] { { 0 }, { 1 } } );
          AssertArray(a, new int[,] { { 0 }, { 1 } });

          int[,] b = (int[,])a;
          AssertArray(a, b);


          ndarray c = np.array(new int[,,] { { { 1, 2 }, { 3, 4 }, { 5, 6 } } });
          AssertArray(c, new int[,,] { { { 1, 2 }, { 3, 4 }, { 5, 6 } } });
          int[,,] d = (int[,,])c;
          AssertArray(c, d);

      }