warp-lang 1.9.1__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/native/array.h

@@ -118,6 +118,23 @@ namespace wp
 
 #endif  // WP_FP_CHECK
 
+
+template<size_t... Is>
+struct index_sequence {};
+
+template<size_t N, size_t... Is>
+struct make_index_sequence_impl : make_index_sequence_impl<N-1, N-1, Is...> {};
+
+template<size_t... Is>
+struct make_index_sequence_impl<0, Is...>
+{
+    using type = index_sequence<Is...>;
+};
+
+template<size_t N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
+
+
 const int ARRAY_MAX_DIMS = 4;       // must match constant in types.py
 
 // must match constants in types.py
@@ -423,6 +440,13 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const array_t<T>& arr, int i)
 {
     assert(arr.ndim == 1);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+
     T& result = *data_at_byte_offset(arr, byte_offset(arr, i));
     FP_VERIFY_FWD_1(result)
 
@@ -433,6 +457,18 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const array_t<T>& arr, int i, int j)
 {
     assert(arr.ndim == 2);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+
     T& result = *data_at_byte_offset(arr, byte_offset(arr, i, j));
     FP_VERIFY_FWD_2(result)
 
@@ -443,6 +479,23 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const array_t<T>& arr, int i, int j, int k)
 {
     assert(arr.ndim == 3);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+    assert(k >= -arr.shape[2] && k < arr.shape[2]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += arr.shape[2];
+    }
+
     T& result = *data_at_byte_offset(arr, byte_offset(arr, i, j, k));
     FP_VERIFY_FWD_3(result)
 
@@ -453,6 +506,28 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const array_t<T>& arr, int i, int j, int k, int l)
 {
     assert(arr.ndim == 4);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+    assert(k >= -arr.shape[2] && k < arr.shape[2]);
+    assert(l >= -arr.shape[3] && l < arr.shape[3]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += arr.shape[2];
+    }
+    if (l < 0)
+    {
+        l += arr.shape[3];
+    }
+
     T& result = *data_at_byte_offset(arr, byte_offset(arr, i, j, k, l));
     FP_VERIFY_FWD_4(result)
 
@@ -462,6 +537,14 @@ CUDA_CALLABLE inline T& index(const array_t<T>& arr, int i, int j, int k, int l)
 template <typename T>
 CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i)
 {
+    assert(arr.ndim == 1);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+
     T& result = *grad_at_byte_offset(arr, byte_offset(arr, i));
     FP_VERIFY_FWD_1(result)
 
@@ -471,6 +554,19 @@ CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i)
 template <typename T>
 CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i, int j)
 {
+    assert(arr.ndim == 2);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+
     T& result = *grad_at_byte_offset(arr, byte_offset(arr, i, j));
     FP_VERIFY_FWD_2(result)
 
@@ -480,6 +576,24 @@ CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i, int j)
 template <typename T>
 CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i, int j, int k)
 {
+    assert(arr.ndim == 3);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+    assert(k >= -arr.shape[2] && k < arr.shape[2]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += arr.shape[2];
+    }
+
     T& result = *grad_at_byte_offset(arr, byte_offset(arr, i, j, k));
     FP_VERIFY_FWD_3(result)
 
@@ -489,6 +603,29 @@ CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i, int j, int k)
 template <typename T>
 CUDA_CALLABLE inline T& index_grad(const array_t<T>& arr, int i, int j, int k, int l)
 {
+    assert(arr.ndim == 4);
+    assert(i >= -arr.shape[0] && i < arr.shape[0]);
+    assert(j >= -arr.shape[1] && j < arr.shape[1]);
+    assert(k >= -arr.shape[2] && k < arr.shape[2]);
+    assert(l >= -arr.shape[3] && l < arr.shape[3]);
+
+    if (i < 0)
+    {
+        i += arr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += arr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += arr.shape[2];
+    }
+    if (l < 0)
+    {
+        l += arr.shape[3];
+    }
+
     T& result = *grad_at_byte_offset(arr, byte_offset(arr, i, j, k, l));
     FP_VERIFY_FWD_4(result)
 
@@ -500,7 +637,12 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const indexedarray_t<T>& iarr, int i)
 {
     assert(iarr.arr.ndim == 1);
-    assert(i >= 0 && i < iarr.shape[0]);
+    assert(i >= -iarr.shape[0] && i < iarr.shape[0]);
+
+    if (i < 0)
+    {
+        i += iarr.shape[0];
+    }
 
     if (iarr.indices[0])
     {
@@ -518,8 +660,17 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const indexedarray_t<T>& iarr, int i, int j)
 {
     assert(iarr.arr.ndim == 2);
-    assert(i >= 0 && i < iarr.shape[0]);
-    assert(j >= 0 && j < iarr.shape[1]);
+    assert(i >= -iarr.shape[0] && i < iarr.shape[0]);
+    assert(j >= -iarr.shape[1] && j < iarr.shape[1]);
+
+    if (i < 0)
+    {
+        i += iarr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += iarr.shape[1];
+    }
 
     if (iarr.indices[0])
     {
@@ -542,9 +693,22 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const indexedarray_t<T>& iarr, int i, int j, int k)
 {
     assert(iarr.arr.ndim == 3);
-    assert(i >= 0 && i < iarr.shape[0]);
-    assert(j >= 0 && j < iarr.shape[1]);
-    assert(k >= 0 && k < iarr.shape[2]);
+    assert(i >= -iarr.shape[0] && i < iarr.shape[0]);
+    assert(j >= -iarr.shape[1] && j < iarr.shape[1]);
+    assert(k >= -iarr.shape[2] && k < iarr.shape[2]);
+
+    if (i < 0)
+    {
+        i += iarr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += iarr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += iarr.shape[2];
+    }
 
     if (iarr.indices[0])
     {
@@ -572,10 +736,27 @@ template <typename T>
 CUDA_CALLABLE inline T& index(const indexedarray_t<T>& iarr, int i, int j, int k, int l)
 {
     assert(iarr.arr.ndim == 4);
-    assert(i >= 0 && i < iarr.shape[0]);
-    assert(j >= 0 && j < iarr.shape[1]);
-    assert(k >= 0 && k < iarr.shape[2]);
-    assert(l >= 0 && l < iarr.shape[3]);
+    assert(i >= -iarr.shape[0] && i < iarr.shape[0]);
+    assert(j >= -iarr.shape[1] && j < iarr.shape[1]);
+    assert(k >= -iarr.shape[2] && k < iarr.shape[2]);
+    assert(l >= -iarr.shape[3] && l < iarr.shape[3]);
+
+    if (i < 0)
+    {
+        i += iarr.shape[0];
+    }
+    if (j < 0)
+    {
+        j += iarr.shape[1];
+    }
+    if (k < 0)
+    {
+        k += iarr.shape[2];
+    }
+    if (l < 0)
+    {
+        l += iarr.shape[3];
+    }
 
     if (iarr.indices[0])
     {
@@ -609,7 +790,12 @@ template <typename T>
 CUDA_CALLABLE inline array_t<T> view(array_t<T>& src, int i)
 {
     assert(src.ndim > 1);
-    assert(i >= 0 && i < src.shape[0]);
+    assert(i >= -src.shape[0] && i < src.shape[0]);
+
+    if (i < 0)
+    {
+        i += src.shape[0];
+    }
 
     array_t<T> a;
     size_t offset = byte_offset(src, i);
@@ -631,8 +817,17 @@ template <typename T>
 CUDA_CALLABLE inline array_t<T> view(array_t<T>& src, int i, int j)
 {
     assert(src.ndim > 2);
-    assert(i >= 0 && i < src.shape[0]);
-    assert(j >= 0 && j < src.shape[1]);
+    assert(i >= -src.shape[0] && i < src.shape[0]);
+    assert(j >= -src.shape[1] && j < src.shape[1]);
+
+    if (i < 0)
+    {
+        i += src.shape[0];
+    }
+    if (j < 0)
+    {
+        j += src.shape[1];
+    }
 
     array_t<T> a;
     size_t offset = byte_offset(src, i, j);
@@ -652,9 +847,22 @@ template <typename T>
 CUDA_CALLABLE inline array_t<T> view(array_t<T>& src, int i, int j, int k)
 {
     assert(src.ndim > 3);
-    assert(i >= 0 && i < src.shape[0]);
-    assert(j >= 0 && j < src.shape[1]);
-    assert(k >= 0 && k < src.shape[2]);
+    assert(i >= -src.shape[0] && i < src.shape[0]);
+    assert(j >= -src.shape[1] && j < src.shape[1]);
+    assert(k >= -src.shape[2] && k < src.shape[2]);
+
+    if (i < 0)
+    {
+        i += src.shape[0];
+    }
+    if (j < 0)
+    {
+        j += src.shape[1];
+    }
+    if (k < 0)
+    {
+        k += src.shape[2];
+    }
 
     array_t<T> a;
     size_t offset = byte_offset(src, i, j, k);
@@ -669,6 +877,78 @@ CUDA_CALLABLE inline array_t<T> view(array_t<T>& src, int i, int j, int k)
 }
 
 
+template <typename T, size_t... Idxs>
+size_t byte_offset_helper(
+    array_t<T>& src,
+    const slice_t (&slices)[sizeof...(Idxs)],
+    index_sequence<Idxs...>
+)
+{
+    return byte_offset(src, slices[Idxs].start...);
+}
+
+
+template <typename T, typename... Slices>
+CUDA_CALLABLE inline array_t<T> view(array_t<T>& src, const Slices&... slice_args)
+{
+    constexpr int N = sizeof...(Slices);
+    static_assert(N >= 1 && N <= 4, "view supports 1 to 4 slices");
+    assert(src.ndim >= N);
+
+    slice_t slices[N] = { slice_args... };
+    int slice_idxs[N];
+    int slice_count = 0;
+
+    for (int i = 0; i < N; ++i)
+    {
+        if (slices[i].step == 0)
+        {
+            // We have a slice representing an integer index.
+            if (slices[i].start < 0)
+            {
+                slices[i].start += src.shape[i];
+            }
+        }
+        else
+        {
+            slices[i] = slice_adjust_indices(slices[i], src.shape[i]);
+            slice_idxs[slice_count] = i;
+            ++slice_count;
+        }
+    }
+
+    size_t offset = byte_offset_helper(src, slices, make_index_sequence<N>{});
+
+    array_t<T> out;
+
+    out.data = data_at_byte_offset(src, offset);
+    if (src.grad)
+    {
+        out.grad = grad_at_byte_offset(src, offset);
+    }
+
+    int dim = 0;
+    for (; dim < slice_count; ++dim)
+    {
+        int idx = slice_idxs[dim];
+        out.shape[dim] = slice_get_length(slices[idx]);
+        out.strides[dim] = src.strides[idx] * slices[idx].step;
+    }
+    for (; dim < slice_count + 4 - N; ++dim)
+    {
+        out.shape[dim] = src.shape[dim - slice_count + N];
+        out.strides[dim] = src.strides[dim - slice_count + N];
+    }
+    for (; dim < 4; ++dim)
+    {
+        out.shape[dim] = 0;
+        out.strides[dim] = 0;
+    }
+
+    out.ndim = src.ndim + slice_count - N;
+    return out;
+}
+
 template <typename T>
 CUDA_CALLABLE inline indexedarray_t<T> view(indexedarray_t<T>& src, int i)
 {
@@ -676,7 +956,11 @@ CUDA_CALLABLE inline indexedarray_t<T> view(indexedarray_t<T>& src, int i)
 
     if (src.indices[0])
     {
-        assert(i >= 0 && i < src.shape[0]);
+        assert(i >= -src.shape[0] && i < src.shape[0]);
+        if (i < 0)
+        {
+            i += src.shape[0];
+        }
         i = src.indices[0][i];
     }
 
@@ -699,12 +983,20 @@ CUDA_CALLABLE inline indexedarray_t<T> view(indexedarray_t<T>& src, int i, int j
 
     if (src.indices[0])
     {
-        assert(i >= 0 && i < src.shape[0]);
+        assert(i >= -src.shape[0] && i < src.shape[0]);
+        if (i < 0)
+        {
+            i += src.shape[0];
+        }
         i = src.indices[0][i];
     }
     if (src.indices[1])
     {
-        assert(j >= 0 && j < src.shape[1]);
+        assert(j >= -src.shape[1] && j < src.shape[1]);
+        if (j < 0)
+        {
+            j += src.shape[1];
+        }
         j = src.indices[1][j];
     }
 
@@ -725,17 +1017,29 @@ CUDA_CALLABLE inline indexedarray_t<T> view(indexedarray_t<T>& src, int i, int j
 
     if (src.indices[0])
     {
-        assert(i >= 0 && i < src.shape[0]);
+        assert(i >= -src.shape[0] && i < src.shape[0]);
+        if (i < 0)
+        {
+            i += src.shape[0];
+        }
         i = src.indices[0][i];
     }
     if (src.indices[1])
     {
-        assert(j >= 0 && j < src.shape[1]);
+        assert(j >= -src.shape[1] && j < src.shape[1]);
+        if (j < 0)
+        {
+            j += src.shape[1];
+        }
         j = src.indices[1][j];
     }
     if (src.indices[2])
     {
-        assert(k >= 0 && k < src.shape[2]);
+        assert(k >= -src.shape[2] && k < src.shape[2]);
+        if (k < 0)
+        {
+            k += src.shape[2];
+        }
         k = src.indices[2][k];
     }
 
@@ -754,6 +1058,9 @@ inline CUDA_CALLABLE void adj_view(A1<T>& src, int i, int j, A2<T>& adj_src, int
 template<template<typename> class A1, template<typename> class A2, template<typename> class A3, typename T>
 inline CUDA_CALLABLE void adj_view(A1<T>& src, int i, int j, int k, A2<T>& adj_src, int adj_i, int adj_j, int adj_k, A3<T>& adj_ret) {}
 
+template <typename... Args>
+CUDA_CALLABLE inline void adj_view(Args&&...) { }
+
 // TODO: lower_bound() for indexed arrays?
 
 template <typename T>
@@ -844,6 +1151,33 @@ inline CUDA_CALLABLE T atomic_exch(const A<T>& buf, int i, int j, int k, T value
 template<template<typename> class A, typename T>
 inline CUDA_CALLABLE T atomic_exch(const A<T>& buf, int i, int j, int k, int l, T value) { return atomic_exch(&index(buf, i, j, k, l), value); }
 
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_and(const A<T>& buf, int i, T value) { return atomic_and(&index(buf, i), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_and(const A<T>& buf, int i, int j, T value) { return atomic_and(&index(buf, i, j), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_and(const A<T>& buf, int i, int j, int k, T value) { return atomic_and(&index(buf, i, j, k), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_and(const A<T>& buf, int i, int j, int k, int l, T value) { return atomic_and(&index(buf, i, j, k, l), value); }
+
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_or(const A<T>& buf, int i, T value) { return atomic_or(&index(buf, i), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_or(const A<T>& buf, int i, int j, T value) { return atomic_or(&index(buf, i, j), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_or(const A<T>& buf, int i, int j, int k, T value) { return atomic_or(&index(buf, i, j, k), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_or(const A<T>& buf, int i, int j, int k, int l, T value) { return atomic_or(&index(buf, i, j, k, l), value); }
+
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_xor(const A<T>& buf, int i, T value) { return atomic_xor(&index(buf, i), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_xor(const A<T>& buf, int i, int j, T value) { return atomic_xor(&index(buf, i, j), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_xor(const A<T>& buf, int i, int j, int k, T value) { return atomic_xor(&index(buf, i, j, k), value); }
+template<template<typename> class A, typename T>
+inline CUDA_CALLABLE T atomic_xor(const A<T>& buf, int i, int j, int k, int l, T value) { return atomic_xor(&index(buf, i, j, k, l), value); }
+
 template<template<typename> class A, typename T>
 inline CUDA_CALLABLE T* address(const A<T>& buf, int i)
 {
@@ -911,20 +1245,7 @@ inline CUDA_CALLABLE T load(T* address)
     return value;
 }
 
-// select operator to check for array being null
-template <typename T1, typename T2>
-CUDA_CALLABLE inline T2 select(const array_t<T1>& arr, const T2& a, const T2& b) { return arr.data?b:a; }
-
-template <typename T1, typename T2>
-CUDA_CALLABLE inline void adj_select(const array_t<T1>& arr, const T2& a, const T2& b, const array_t<T1>& adj_cond, T2& adj_a, T2& adj_b, const T2& adj_ret)
-{
-    if (arr.data)
-        adj_b += adj_ret;
-    else
-        adj_a += adj_ret;
-}
-
-// where operator to check for array being null, opposite convention compared to select
+// where() overload for array condition - returns a if array.data is non-null, otherwise returns b
 template <typename T1, typename T2>
 CUDA_CALLABLE inline T2 where(const array_t<T1>& arr, const T2& a, const T2& b) { return arr.data?a:b; }
 
@@ -1321,6 +1642,34 @@ inline CUDA_CALLABLE void adj_atomic_exch(const A1<T>& buf, int i, int j, int k,
     FP_VERIFY_ADJ_4(value, adj_value)
 }
 
+// for bitwise operations we do not accumulate gradients
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_and(const A1<T>& buf, int i, T value, const A2<T>& adj_buf, int adj_i, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_and(const A1<T>& buf, int i, int j, T value, const A2<T>& adj_buf, int adj_i, int adj_j, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_and(const A1<T>& buf, int i, int j, int k, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_and(const A1<T>& buf, int i, int j, int k, int l, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, int adj_l, T& adj_value, const T& adj_ret) {}
+
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_or(const A1<T>& buf, int i, T value, const A2<T>& adj_buf, int adj_i, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_or(const A1<T>& buf, int i, int j, T value, const A2<T>& adj_buf, int adj_i, int adj_j, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_or(const A1<T>& buf, int i, int j, int k, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_or(const A1<T>& buf, int i, int j, int k, int l, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, int adj_l, T& adj_value, const T& adj_ret) {}
+
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_xor(const A1<T>& buf, int i, T value, const A2<T>& adj_buf, int adj_i, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_xor(const A1<T>& buf, int i, int j, T value, const A2<T>& adj_buf, int adj_i, int adj_j, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_xor(const A1<T>& buf, int i, int j, int k, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, T& adj_value, const T& adj_ret) {}
+template<template<typename> class A1, template<typename> class A2, typename T>
+inline CUDA_CALLABLE void adj_atomic_xor(const A1<T>& buf, int i, int j, int k, int l, T value, const A2<T>& adj_buf, int adj_i, int adj_j, int adj_k, int adj_l, T& adj_value, const T& adj_ret) {}
+
 
 template<template<typename> class A, typename T>
 CUDA_CALLABLE inline int len(const A<T>& a)
@@ -1333,7 +1682,6 @@ CUDA_CALLABLE inline void adj_len(const A<T>& a, A<T>& adj_a, int& adj_ret)
 {
 }
 
-
 } // namespace wp
 
 #include "fabric.h"