Fix Nx.slice crash on scalar tensor

[blasphemetheus]

If you run Nx.slice on a scalar tensor [tensor with no dimensions, just a single number wrapped in a tensor struct] (aka rank 0), it throws an error

Nx.slice(Nx.tensor(42), [], [])
# ** (ArgError) 1st argument: not a nonempty list
#      :erlang.hd([])
...

Slicing a scalar is a valid no-op. Nx.Shape.slice does it fine. But here BinaryBackend.bin_slice/7 calls hd(strides) on the empty strides list [], which crashes.

The fix is to add a scalar guard clause that matches when all lists are empty and returns the data unchanged.

running scalar_slice_test.exs on main

     Nx.ScalarSliceTest [test/nx/scalar_slice_test.exs]                                 
       * test slice of scalar tensor returns scalar [L#4]                               
       * test slice of scalar tensor returns scalar (20.5ms) [L#4]                      
                                                                                        
       1) test slice of scalar tensor returns scalar (Nx.ScalarSliceTest)               
          test/nx/scalar_slice_test.exs:4                                               
          ** (ArgumentError) errors were found at the given arguments:                  
                                                                                        
            * 1st argument: not a nonempty list                                         
                                                                                        
          code: result = Nx.slice(t, [], [])                                            
          stacktrace:                                                                   
            :erlang.hd([])                                                              
            (nx 0.11.0) lib/nx/binary_backend.ex:1855: Nx.BinaryBackend.bin_slice/7     
            (nx 0.11.0) lib/nx/binary_backend.ex:1848: Nx.BinaryBackend.slice/5         
            (nx 0.11.0) lib/nx.ex:13738: Nx.slice/4                                     
            test/nx/scalar_slice_test.exs:6: (test)                                     
...

originally part of the closed fuzz test edge case PR #1707

[josevalim]

Instead of a separate module, let's add a function to nx_test.exs. I would also add a doctest that says:

Sliding a one-dimensional tensor is a no-op:

iex> Nx.slice(42, [], [])

WDYT?

[blasphemetheus]

sounds good! I'll go through and apply that idea to the other PRs too, just adding em at the end of nx_test.exs

[polvalente]

I'm not sure we should support slicing scalars.
Furthermore, if we're adding support for this, we should also check how EXLA and Torchx behave.

I think the correct PR here is to fail on scalar slicing

[josevalim]

Slicing a scalar could always be a no-op if you pass no dimensions (and raise if you pass any) so there is nothing to be implemented on the other backends because there is no operation.

[josevalim]

FWIW:

import numpy as np
x = np.array(5)
x[()]  # returns 5

But the current implementation requires indeed each backend to implement it (but the doctest should test them aleady)

[blasphemetheus]

gotcha, so if the check for this case is to be applied, it shouldn't just live in binary backend, it should live in Nx.slice, can do!

also I changed a test value from 3.15 to 3.14 in that commit, i think a typo from earlier

[blasphemetheus]

ci failure:

  1) test pinv does not raise for 0 singular values (Nx.LinAlgTest)
Error:      test/nx/lin_alg_test.exs:1025
     ** (ArithmeticError) bad argument in arithmetic expression
     stacktrace:
       (complex 0.6.0) lib/complex.ex:579: Complex.divide/2
       (nx 0.11.0) lib/nx/binary_backend.ex:707: anonymous fn/11 in Nx.BinaryBackend.element_wise_bin_op/4
       (elixir 1.18.4) lib/enum.ex:4507: Enum.reduce/3
       (nx 0.11.0) lib/nx/binary_backend.ex:698: Nx.BinaryBackend.element_wise_bin_op/4
       (nx 0.11.0) lib/nx/defn/evaluator.ex:426: Nx.Defn.Evaluator.eval_apply/5
       (nx 0.11.0) lib/nx/defn/evaluator.ex:257: Nx.Defn.Evaluator.eval/3
       (elixir 1.18.4) lib/enum.ex:1840: Enum."-map_reduce/3-lists^mapfoldl/2-0-"/3
       (elixir 1.18.4) lib/enum.ex:1840: Enum."-map_reduce/3-lists^mapfoldl/2-0-"/3
       (nx 0.11.0) lib/nx/defn/evaluator.ex:404: Nx.Defn.Evaluator.eval_apply/5
       (nx 0.11.0) lib/nx/defn/evaluator.ex:257: Nx.Defn.Evaluator.eval/3
       (elixir 1.18.4) lib/enum.ex:1840: Enum."-map_reduce/3-lists^mapfoldl/2-0-"/3
       (nx 0.11.0) lib/nx/defn/evaluator.ex:404: Nx.Defn.Evaluator.eval_apply/5
       (nx 0.11.0) lib/nx/defn/evaluator.ex:257: Nx.Defn.Evaluator.eval/3
       (elixir 1.18.4) lib/enum.ex:1840: Enum."-map_reduce/3-lists^mapfoldl/2-0-"/3
       (elixir 1.18.4) lib/enum.ex:1840: Enum."-map_reduce/3-lists^mapfoldl/2-0-"/3
       (nx 0.11.0) lib/nx/defn/evaluator.ex:404: Nx.Defn.Evaluator.eval_apply/5
       (nx 0.11.0) lib/nx/defn/evaluator.ex:257: Nx.Defn.Evaluator.eval/3
       (nx 0.11.0) lib/nx/defn/tree.ex:235: Nx.Defn.Tree.apply_args/4
       (nx 0.11.0) lib/nx/defn/evaluator.ex:404: Nx.Defn.Evaluator.eval_apply/5
       (nx 0.11.0) lib/nx/defn/evaluator.ex:257: Nx.Defn.Evaluator.eval/3

https://github.com/elixir-nx/nx/actions/runs/23414733273/job/68108024086?pr=1712

internally its a divide by 0 looks like, should be fixed in elixir-nx/complex#29