[?] Correct Subarray With Negative Domains on Dense Arrays

* We currently support Python negative indexing ie. where -1 returns
  the last element in the sequence. However, this conflicts with reading
  and writing with negative subarray values -- indexing with negative
  values errors out.
* This PR deprecates the usage of Pythoh negative indexing so that dense
  arrays with negative domains can be indexed by TileDB dimensions
  correctly.

Author: nguyenv

tiledb/libtiledb.pyx

@@ -589,6 +589,8 @@ def index_domain_subarray(array: Array, dom, idx: tuple):
     Return a numpy array representation of the tiledb subarray buffer
     for a given domain and tuple of index slices
     """
+    offsetted = False
+
     ndim = dom.ndim
     if len(idx) != ndim:
         raise IndexError("number of indices does not match domain rank: "
@@ -648,7 +650,9 @@ def index_domain_subarray(array: Array, dom, idx: tuple):
                     raise IndexError("cannot index integral domain dimension with non-integral slice (dtype: {})".format(type(start)))
             # apply negative indexing (wrap-around semantics)
             if not is_datetime and start < 0:
-                start += int(dim_ub) + 1
+                if start < dim_lb:
+                    offsetted = True
+                    start += int(dim_ub) + 1
             if start < dim_lb:
                 # numpy allows start value < the array dimension shape,
                 # clamp to lower bound of dimension domain
@@ -666,7 +670,8 @@ def index_domain_subarray(array: Array, dom, idx: tuple):
                 elif not isinstance(start, _inttypes):
                     raise IndexError("cannot index integral domain dimension with non-integral slice (dtype: {})".format(type(start)))
             if not is_datetime and stop < 0:
-                stop += dim_ub
+                if offsetted:
+                    stop += dim_ub
             if stop > dim_ub:
                 # numpy allows stop value > than the array dimension shape,
                 # clamp to upper bound of dimension domain

tiledb/tests/test_libtiledb.py

@@ -503,7 +503,7 @@ def test_array_1d(self):
             # basic step
             assert_array_equal(A[:50:2], T[:50:2])
             assert_array_equal(A[:2:50], T[:2:50])
-            assert_array_equal(A[10:-1:50], T[10:-1:50])
+            assert_array_equal(A[10:-1:50], T[10:1049:50])
 
             # indexing errors
             with self.assertRaises(IndexError):
@@ -1247,7 +1247,7 @@ def test_varlen_sparse_all_empty_strings(self):
 
         with tiledb.open(uri, mode="r") as T:
             # check interior range
-            assert_array_equal(A[1:-1], T[2:-1]["a1"])
+            assert_array_equal(A[1:-1], T[1:dim_len-1]["a1"])
             assert_array_equal(A[1:-1], T.multi_index[2 : dim_len - 1]["a1"])
 
     def test_varlen_write_unicode(self):
@@ -1521,6 +1521,51 @@ def test_array_varlen_2d_s_fixed(self):
         with tiledb.DenseArray(uri) as T:
             assert_array_equal(A, T)
 
+    @pytest.mark.parametrize("lo,hi", [(-20, -10), (-10, 0), (0, 10), (10, 20)])
+    def test_dense_array_with_negative_positive_domain(self, lo, hi):
+        path = self.path("test_dense_array_with_negative_domain")
+        attr = tiledb.Attr(dtype=np.uint8)
+        dom = tiledb.Domain(tiledb.Dim("X", domain=(-20, 20),dtype=np.int64))
+        schema = tiledb.ArraySchema(domain=dom, sparse=False, attrs=[attr])
+        tiledb.Array.create(path, schema)
+        data = np.random.randint(10, size=(hi-lo))
+
+        with tiledb.open(path, 'w') as A:
+            A[lo:hi] = data
+        
+        with tiledb.open(path, 'r') as A:
+            assert_array_equal(A[lo:hi], data[:])
+            
+
+    @pytest.mark.parametrize("lo,hi", [(-20, -10), (-20, -15), (-15, -10), (-17, -13)])
+    def test_dense_array_with_negative_negative_domain(self, lo, hi):
+        path = self.path("test_dense_array_with_negative_negative_domain")
+        attr = tiledb.Attr(dtype=np.uint8)
+        dom = tiledb.Domain(tiledb.Dim("X", domain=(-20, -10),dtype=np.int64))
+        schema = tiledb.ArraySchema(domain=dom, sparse=False, attrs=[attr])
+        tiledb.Array.create(path, schema)
+        data = np.random.randint(10, size=(hi-lo))
+
+        with tiledb.open(path, 'w') as A:
+            A[lo:hi] = data
+            
+        with tiledb.open(path, 'r') as A:
+            assert_array_equal(A[lo:hi], data[:])
+            
+    @pytest.mark.parametrize("lo,hi", [(10, 20), (10,15),(12,15), (17,20)])
+    def test_dense_array_with_offset_domain(self, lo, hi):
+        path = self.path("test_dense_array_with_offset_domain")
+        attr = tiledb.Attr(dtype=np.uint8)
+        dom = tiledb.Domain(tiledb.Dim("X", domain=(10, 20),dtype=np.int64))
+        schema = tiledb.ArraySchema(domain=dom, sparse=False, attrs=[attr])
+        tiledb.Array.create(path, schema)
+        data = np.random.randint(10, size=(hi-lo))
+
+        with tiledb.open(path, 'w') as A:
+            A[lo:hi] = data
+        
+        with tiledb.open(path, 'r') as A:
+            assert_array_equal(A[lo:hi], data[:])
 
 class TestSparseArray(DiskTestCase):
     @pytest.mark.xfail