warp-lang 1.8.1__py3-none-manylinux_2_34_aarch64.whl → 1.9.1__py3-none-manylinux_2_34_aarch64.whl

warp/native/mat.h

@@ -177,12 +177,12 @@ struct mat_t
 
     CUDA_CALLABLE vec_t<Cols,Type> get_row(int index) const
     {
-        return (vec_t<Cols,Type>&)data[index]; 
+        return reinterpret_cast<const vec_t<Cols,Type>&>(data[index]); 
     }
 
     CUDA_CALLABLE void set_row(int index, const vec_t<Cols,Type>& v)
     {
-        (vec_t<Cols,Type>&)data[index] = v;
+        reinterpret_cast<vec_t<Cols,Type>&>(data[index]) = v;
     }
 
     CUDA_CALLABLE vec_t<Rows,Type> get_col(int index) const
@@ -204,7 +204,7 @@ struct mat_t
     }
 
     // row major storage assumed to be compatible with PyTorch
-    Type data[Rows][Cols];
+    Type data[Rows < 1 ? 1 : Rows][Cols < 1 ? 1 : Cols];
 };
 
 template<typename Type>
@@ -477,6 +477,20 @@ template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE vec_t<Cols,Type> extract(const mat_t<Rows,Cols,Type>& m, int row)
 {
     vec_t<Cols,Type> ret;
+
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
     for(unsigned i=0; i < Cols; ++i)
     {
         ret.c[i] = m.data[row][i];
@@ -488,31 +502,206 @@ template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE Type extract(const mat_t<Rows,Cols,Type>& m, int row, int col)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
     return m.data[row][col];
 }
 
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<RowSliceLength, ColSliceLength, Type> extract(const mat_t<Rows,Cols,Type>& m, slice_t row_slice)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    mat_t<RowSliceLength, ColSliceLength, Type> ret;
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            ret.data[ii][j] = m.data[i][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+    return ret;
+}
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE vec_t<RowSliceLength, Type> extract(const mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    vec_t<RowSliceLength, Type> ret;
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        ret.c[ii] = m.data[i][col];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+    return ret;
+}
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE vec_t<ColSliceLength, Type> extract(const mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    vec_t<ColSliceLength, Type> ret;
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        ret.c[ii] = m.data[row][i];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+    return ret;
+}
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<RowSliceLength, ColSliceLength, Type> extract(const mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice)
+{
+    mat_t<RowSliceLength, ColSliceLength, Type> ret;
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            ret.data[ii][jj] = m.data[i][j];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+    return ret;
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE vec_t<Cols, Type>* index(mat_t<Rows,Cols,Type>& m, int row)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
     return reinterpret_cast<vec_t<Cols, Type>*>(&m.data[row]);
 }
 
@@ -520,38 +709,46 @@ template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE Type* index(mat_t<Rows,Cols,Type>& m, int row, int col)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
     return &m.data[row][col];
 }
 
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE void adj_index(const mat_t<Rows,Cols,Type>& m, int row,
-                                       const mat_t<Rows,Cols,Type>& adj_m, int adj_row, const vec_t<Cols, Type>& adj_value)
+                                    const mat_t<Rows,Cols,Type>& adj_m, int adj_row, const vec_t<Cols, Type>& adj_value)
 {
     // nop
 }
 
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE void adj_index(const mat_t<Rows,Cols,Type>& m, int row, int col,
-                                       const mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, Type adj_value)
+                                    const mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, Type adj_value)
 {
     // nop
 }
 
-
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+inline CUDA_CALLABLE Type* indexref(mat_t<Rows,Cols,Type>* m, int row, int col)
 {
 #ifndef NDEBUG
     if (row < 0 || row >= Rows)
@@ -566,201 +763,1091 @@ inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, int col
     }
 #endif
 
-    m.data[row][col] += value;
+    return &(m->data)[row][col];
 }
 
-
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+inline CUDA_CALLABLE void adj_indexref(mat_t<Rows,Cols,Type>* m, int row, int col, 
+                                       mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, const Type& adj_value)
 {
-#ifndef NDEBUG
-    if (row < 0 || row >= Rows)
-    {
-        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
-        assert(0);
-    }
-#endif
-
-    for(unsigned i=0; i < Cols; ++i)
-    {
-        m.data[row][i] += value[i];
-    }
+    // nop
 }
 
 
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_add_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
-                                        mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, Type& adj_value)
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    adj_value += adj_m.data[row][col];
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    m.data[row][col] += value;
 }
 
 
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_add_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
-                                        mat_t<Rows,Cols,Type>& adj_m, int adj_row, vec_t<Cols,Type>& adj_value)
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
     for(unsigned i=0; i < Cols; ++i)
     {
-        adj_value[i] += adj_m.data[row][i];
+        m.data[row][i] += value[i];
     }
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
 {
-#ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
     {
-        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
-        assert(0);
+        for (int j = 0; j < Cols; ++j)
+        {
+            m.data[i][j] += value.data[ii][j];
+        }
+
+        ++ii;
     }
-    if (col < 0 || col >= Cols)
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    m.data[row][col] -= value;
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        m.data[i][col] += value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    for(unsigned i=0; i < Cols; ++i)
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
     {
-        m.data[row][i] -= value[i];
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        m.data[row][i] += value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void add_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            m.data[i][j] += value.data[ii][jj];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
     }
+
+    assert(ii == RowSliceLength);
 }
 
 
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_sub_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
+inline CUDA_CALLABLE void adj_add_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
                                         mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, Type& adj_value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    adj_value -= adj_m.data[row][col];
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    adj_value += adj_m.data[row][col];
 }
 
 
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_sub_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
+inline CUDA_CALLABLE void adj_add_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
                                         mat_t<Rows,Cols,Type>& adj_m, int adj_row, vec_t<Cols,Type>& adj_value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
     for(unsigned i=0; i < Cols; ++i)
     {
-        adj_value[i] -= adj_m.data[row][i];
+        adj_value[i] += adj_m.data[row][i];
     }
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_add_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
 {
-#ifndef NDEBUG
-    if (row < 0 || row >= Rows)
-    {
-        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
-        assert(0);
-    }
-    if (col < 0 || col >= Cols)
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
     {
-        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
-        assert(0);
+        for (int j = 0; j < Cols; ++j)
+        {
+            adj_value.data[ii][j] += adj_m.data[i][j];
+        }
+
+        ++ii;
     }
-#endif
 
-    m.data[row][col] = value;
+    assert(ii == RowSliceLength);
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_add_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, int& adj_col, vec_t<RowSliceLength, Type>& adj_value
+)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
-        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    for(unsigned i=0; i < Cols; ++i)
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
     {
-        m.data[row][i] = value[i];
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        adj_value.c[ii] += adj_m.data[i][col];
+        ++ii;
     }
+
+    assert(ii == RowSliceLength);
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_assign_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
-                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, int& adj_col, Type& adj_value)
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_add_inplace(
+    mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, int& adj_row, slice_t& adj_col_slice, vec_t<ColSliceLength, Type>& adj_value
+)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        adj_value.c[ii] += adj_m.data[row][i];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_add_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, slice_t& adj_col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            adj_value.data[ii][jj] += adj_m.data[i][j];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    m.data[row][col] -= value;
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    for(unsigned i=0; i < Cols; ++i)
+    {
+        m.data[row][i] -= value[i];
+    }
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            m.data[i][j] -= value.data[ii][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        m.data[i][col] -= value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        m.data[row][i] -= value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void sub_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            m.data[i][j] -= value.data[ii][jj];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
+                                        mat_t<Rows,Cols,Type>& adj_m, int adj_row, int adj_col, Type& adj_value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    adj_value -= adj_m.data[row][col];
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
+                                        mat_t<Rows,Cols,Type>& adj_m, int adj_row, vec_t<Cols,Type>& adj_value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    for(unsigned i=0; i < Cols; ++i)
+    {
+        adj_value[i] -= adj_m.data[row][i];
+    }
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            adj_value.data[ii][j] -= adj_m.data[i][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, int& adj_col, vec_t<RowSliceLength, Type>& adj_value
+)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        adj_value.c[ii] -= adj_m.data[i][col];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(
+    mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, int& adj_row, slice_t& adj_col_slice, vec_t<ColSliceLength, Type>& adj_value
+)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        adj_value.c[ii] -= adj_m.data[row][i];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, slice_t& adj_col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            adj_value.data[ii][jj] -= adj_m.data[i][j];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    m.data[row][col] = value;
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    for(unsigned i=0; i < Cols; ++i)
+    {
+        m.data[row][i] = value[i];
+    }
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            m.data[i][j] = value.data[ii][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        m.data[i][col] = value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        m.data[row][i] = value.c[ii];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void assign_inplace(mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            m.data[i][j] = value.data[ii][jj];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_inplace(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
+                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, int& adj_col, Type& adj_value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
     adj_value += adj_m.data[row][col];
 }
 
@@ -770,13 +1857,18 @@ inline CUDA_CALLABLE void adj_assign_inplace(mat_t<Rows,Cols,Type>& m, int row,
                                         mat_t<Rows,Cols,Type>& adj_m, int& adj_row, vec_t<Cols,Type>& adj_value)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
     for(unsigned i=0; i < Cols; ++i)
     {
         adj_value[i] += adj_m.data[row][i];
@@ -784,99 +1876,563 @@ inline CUDA_CALLABLE void adj_assign_inplace(mat_t<Rows,Cols,Type>& m, int row,
 }
 
 
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            adj_value.data[ii][j] += adj_m.data[i][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, int& adj_col, vec_t<RowSliceLength, Type>& adj_value
+)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        adj_value.c[ii] += adj_m.data[i][col];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_inplace(
+    mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, int& adj_row, slice_t& adj_col_slice, vec_t<ColSliceLength, Type>& adj_value
+)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        adj_value.c[ii] += adj_m.data[row][i];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_inplace(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, slice_t& adj_col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value
+)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            adj_value.data[ii][jj] += adj_m.data[i][j];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    mat_t<Rows,Cols,Type> ret(m);
+    ret.data[row][col] = value;
+    return ret;
+}
+
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    mat_t<Rows,Cols,Type> ret(m);
+    for(unsigned i=0; i < Cols; ++i)
+    {
+        ret.data[row][i] = value[i];
+    }
+    return ret;
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    mat_t<Rows, Cols, Type> ret(m);
+    assign_inplace(ret, row_slice, value);
+    return ret;
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value)
+{
+    mat_t<Rows, Cols, Type> ret(m);
+    assign_inplace(ret, row_slice, col, value);
+    return ret;
+}
+
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value)
+{
+    mat_t<Rows, Cols, Type> ret(m);
+    assign_inplace(ret, row, col_slice, value);
+    return ret;
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value)
+{
+    mat_t<Rows, Cols, Type> ret(m);
+    assign_inplace(ret, row_slice, col_slice, value);
+    return ret;
+}
+
+
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, int row, int col, Type value)
+inline CUDA_CALLABLE void adj_assign_copy(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
+                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, int& adj_col, Type& adj_value, const mat_t<Rows,Cols,Type>& adj_ret)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col >= Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    mat_t<Rows,Cols,Type> ret(m);
-    ret.data[row][col] = value;
-    return ret;
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    adj_value += adj_ret.data[row][col];
+    for(unsigned i=0; i < Rows; ++i)
+    {
+        for(unsigned j=0; j < Cols; ++j)
+        {
+            if(i != row || j != col)
+                adj_m.data[i][j] += adj_ret.data[i][j];
+        }
+    }
 }
 
 
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE mat_t<Rows,Cols,Type> assign_copy(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value)
+inline CUDA_CALLABLE void adj_assign_copy(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
+                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, vec_t<Cols,Type>& adj_value, const mat_t<Rows,Cols,Type>& adj_ret)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    mat_t<Rows,Cols,Type> ret(m);
-    for(unsigned i=0; i < Cols; ++i)
+    if (row < 0)
     {
-        ret.data[row][i] = value[i];
+        row += Rows;
+    }
+
+    for(unsigned i=0; i < Rows; ++i)
+    {
+        for(unsigned j=0; j < Cols; ++j)
+        {
+            if (i==row)
+                adj_value[j] += adj_ret.data[i][j];
+            else
+                adj_m.data[i][j] += adj_ret.data[i][j];
+        }
     }
-    return ret;
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_assign_copy(mat_t<Rows,Cols,Type>& m, int row, int col, Type value,
-                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, int& adj_col, Type& adj_value, const mat_t<Rows,Cols,Type>& adj_ret)
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_copy(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value,
+    mat_t<Rows,Cols,Type>& adj_ret
+)
 {
-#ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (int i = 0; i < Rows; ++i)
     {
-        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
-        assert(0);
+        bool in_row_slice = is_row_reversed
+            ? (i <= row_slice.start && i > row_slice.stop && (row_slice.start - i) % (-row_slice.step) == 0)
+            : (i >= row_slice.start && i < row_slice.stop && (i - row_slice.start) % row_slice.step == 0);
+
+        if (!in_row_slice)
+        {
+            for (int j = 0; j < Cols; ++j)
+            {
+                adj_m.data[i][j] += adj_ret.data[i][j];
+            }
+        }
+        else
+        {
+            for (int j = 0; j < Cols; ++j)
+            {
+                adj_value.data[ii][j] += adj_ret.data[i][j];
+            }
+
+            ++ii;
+        }
     }
-    if (col < 0 || col >= Cols)
+
+    assert(ii == RowSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_copy(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col, vec_t<RowSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, int& adj_col, vec_t<RowSliceLength, Type>& adj_value,
+    mat_t<Rows,Cols,Type>& adj_ret
+)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    adj_value += adj_ret.data[row][col];
-    for(unsigned i=0; i < Rows; ++i)
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
     {
-        for(unsigned j=0; j < Cols; ++j)
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (int i = 0; i < Rows; ++i)
+    {
+        bool in_row_slice = is_row_reversed
+            ? (i <= row_slice.start && i > row_slice.stop && (row_slice.start - i) % (-row_slice.step) == 0)
+            : (i >= row_slice.start && i < row_slice.stop && (i - row_slice.start) % row_slice.step == 0);
+
+        if (!in_row_slice)
         {
-            if(i != row || j != col)
+            for (int j = 0; j < Cols; ++j)
+            {
                 adj_m.data[i][j] += adj_ret.data[i][j];
+            }
+        }
+        else
+        {
+            for (int j = 0; j < Cols; ++j)
+            {
+                if (j != col)
+                {
+                    adj_m.data[i][j] += adj_ret.data[i][j];
+                }
+                else
+                {
+                    adj_value.c[ii] += adj_ret.data[i][j];
+                }
+            }
+
+            ++ii;
         }
     }
+
+    assert(ii == RowSliceLength);
 }
 
 
-template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE void adj_assign_copy(mat_t<Rows,Cols,Type>& m, int row, vec_t<Cols,Type>& value,
-                                        mat_t<Rows,Cols,Type>& adj_m, int& adj_row, vec_t<Cols,Type>& adj_value, const mat_t<Rows,Cols,Type>& adj_ret)
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_copy(
+    mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice, vec_t<ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, int& adj_row, slice_t& adj_col_slice, vec_t<ColSliceLength, Type>& adj_value,
+    mat_t<Rows,Cols,Type>& adj_ret
+)
 {
 #ifndef NDEBUG
-    if (row < 0 || row >= Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
 #endif
 
-    for(unsigned i=0; i < Rows; ++i)
+    if (row < 0)
     {
-        for(unsigned j=0; j < Cols; ++j)
+        row += Rows;
+    }
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (int i = 0; i < Rows; ++i)
+    {
+        if (i != row)
         {
-            if (i==row)
-                adj_value[j] += adj_ret.data[i][j];
-            else
+            for (int j = 0; j < Cols; ++j)
+            {
+                adj_m.data[i][j] += adj_ret.data[i][j];
+            }
+        }
+        else
+        {
+            for (int j = 0; j < Cols; ++j)
+            {
+                bool in_col_slice = is_col_reversed
+                    ? (j <= col_slice.start && j > col_slice.stop && (col_slice.start - j) % (-col_slice.step) == 0)
+                    : (j >= col_slice.start && j < col_slice.stop && (j - col_slice.start) % col_slice.step == 0);
+
+                if (!in_col_slice)
+                {
+                    adj_m.data[i][j] += adj_ret.data[i][j];
+                }
+                else
+                {
+                    adj_value.c[ii] += adj_ret.data[i][j];
+                    ++ii;
+                }
+            }
+        }
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_assign_copy(
+    mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& value,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, slice_t& adj_col_slice, mat_t<RowSliceLength, ColSliceLength, Type>& adj_value,
+    mat_t<Rows,Cols,Type>& adj_ret
+)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (int i = 0; i < Rows; ++i)
+    {
+        bool in_row_slice = is_row_reversed
+            ? (i <= row_slice.start && i > row_slice.stop && (row_slice.start - i) % (-row_slice.step) == 0)
+            : (i >= row_slice.start && i < row_slice.stop && (i - row_slice.start) % row_slice.step == 0);
+
+        if (!in_row_slice)
+        {
+            for (int j = 0; j < Cols; ++j)
+            {
                 adj_m.data[i][j] += adj_ret.data[i][j];
+            }
+        }
+        else
+        {
+            assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+            assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+            assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+            assert(slice_get_length(col_slice) == ColSliceLength);
+
+            int jj = 0;
+            for (int j = 0; j < Cols; ++j)
+            {
+                bool in_col_slice = is_col_reversed
+                    ? (j <= col_slice.start && j > col_slice.stop && (col_slice.start - j) % (-col_slice.step) == 0)
+                    : (j >= col_slice.start && j < col_slice.stop && (j - col_slice.start) % col_slice.step == 0);
+
+                if (!in_col_slice)
+                {
+                    adj_m.data[i][j] += adj_ret.data[i][j];
+                }
+                else
+                {
+                    adj_value.data[ii][jj] += adj_ret.data[i][j];
+                    ++jj;
+                }
+            }
+
+            assert(jj == ColSliceLength);
+            ++ii;
         }
     }
+
+    assert(ii == RowSliceLength);
 }
 
 
@@ -940,6 +2496,21 @@ inline CUDA_CALLABLE mat_t<Rows,Cols,Type> add(const mat_t<Rows,Cols,Type>& a, c
     return t;
 }
 
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> add(Type a, const mat_t<Rows,Cols,Type>& b)
+{
+    mat_t<Rows,Cols,Type> t;
+    for (unsigned i=0; i < Rows; ++i)
+    {
+        for (unsigned j=0; j < Cols; ++j)
+        {
+            t.data[i][j] = a + b.data[i][j];
+        }
+    }
+
+    return t;
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE mat_t<Rows,Cols,Type> sub(const mat_t<Rows,Cols,Type>& a, const mat_t<Rows,Cols,Type>& b)
 {
@@ -955,6 +2526,21 @@ inline CUDA_CALLABLE mat_t<Rows,Cols,Type> sub(const mat_t<Rows,Cols,Type>& a, c
     return t;
 }
 
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> sub(Type a, const mat_t<Rows,Cols,Type>& b)
+{
+    mat_t<Rows,Cols,Type> t;
+    for (unsigned i=0; i < Rows; ++i)
+    {
+        for (unsigned j=0; j < Cols; ++j)
+        {
+            t.data[i][j] = a - b.data[i][j];
+        }
+    }
+
+    return t;
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE mat_t<Rows,Cols,Type> div(const mat_t<Rows,Cols,Type>& a, Type b)
 {
@@ -1469,20 +3055,194 @@ template<unsigned Rows, unsigned Cols, typename Type>
 inline void CUDA_CALLABLE adj_extract(const mat_t<Rows,Cols,Type>& m, int row, int col, mat_t<Rows,Cols,Type>& adj_m, int& adj_row, int& adj_col, Type adj_ret)
 {
 #ifndef NDEBUG
-    if (row < 0 || row > Rows)
+    if (row < -(int)Rows || row >= (int)Rows)
     {
         printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
         assert(0);
     }
-    if (col < 0 || col > Cols)
+    if (col < -(int)Cols || col >= (int)Cols)
     {
         printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
         assert(0);
     }
 #endif
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
     adj_m.data[row][col] += adj_ret;
 }
 
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_extract(
+    const mat_t<Rows,Cols,Type>& m, slice_t row_slice,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice,
+    const mat_t<RowSliceLength, ColSliceLength, Type>& adj_ret
+)
+{
+    static_assert(
+        RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols,
+        "Expected RowSliceLength == 0 ? ColSliceLength == 0 : ColSliceLength == Cols"
+    );
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        for (int j = 0; j < Cols; ++j)
+        {
+            adj_m.data[i][j] += adj_ret.data[ii][j];
+        }
+
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+template<unsigned RowSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_extract(
+    const mat_t<Rows,Cols,Type>& m, slice_t row_slice, int col,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, int& adj_col,
+    const vec_t<RowSliceLength, Type>& adj_ret
+)
+{
+#ifndef NDEBUG
+    if (col < -(int)Cols || col >= (int)Cols)
+    {
+        printf("mat col index %d out of bounds at %s %d\n", col, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    if (col < 0)
+    {
+        col += Cols;
+    }
+
+    bool is_row_reversed = row_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        adj_m.data[i][col] += adj_ret.c[ii];
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
+template<unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_extract(
+    const mat_t<Rows,Cols,Type>& m, int row, slice_t col_slice,
+    mat_t<Rows,Cols,Type>& adj_m, int& adj_row, slice_t& adj_col_slice,
+    const vec_t<ColSliceLength, Type>& adj_ret
+)
+{
+#ifndef NDEBUG
+    if (row < -(int)Rows || row >= (int)Rows)
+    {
+        printf("mat row index %d out of bounds at %s %d\n", row, __FILE__, __LINE__);
+        assert(0);
+    }
+#endif
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    if (row < 0)
+    {
+        row += Rows;
+    }
+
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = col_slice.start;
+        is_col_reversed ? (i > col_slice.stop) : (i < col_slice.stop);
+        i += col_slice.step
+    )
+    {
+        adj_m.data[row][i] += adj_ret.c[ii];
+        ++ii;
+    }
+
+    assert(ii == ColSliceLength);
+}
+
+template<unsigned RowSliceLength, unsigned ColSliceLength, unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_extract(
+    const mat_t<Rows,Cols,Type>& m, slice_t row_slice, slice_t col_slice,
+    mat_t<Rows,Cols,Type>& adj_m, slice_t& adj_row_slice, slice_t& adj_col_slice,
+    const mat_t<RowSliceLength, ColSliceLength, Type>& adj_ret
+)
+{
+    assert(row_slice.start >= 0 && row_slice.start <= (int)Rows);
+    assert(row_slice.stop >= -1 && row_slice.stop <= (int)Rows);
+    assert(row_slice.step != 0 && row_slice.step < 0 ? row_slice.start >= row_slice.stop : row_slice.start <= row_slice.stop);
+    assert(slice_get_length(row_slice) == RowSliceLength);
+
+    assert(col_slice.start >= 0 && col_slice.start <= (int)Cols);
+    assert(col_slice.stop >= -1 && col_slice.stop <= (int)Cols);
+    assert(col_slice.step != 0 && col_slice.step < 0 ? col_slice.start >= col_slice.stop : col_slice.start <= col_slice.stop);
+    assert(slice_get_length(col_slice) == ColSliceLength);
+
+    bool is_row_reversed = row_slice.step < 0;
+    bool is_col_reversed = col_slice.step < 0;
+
+    int ii = 0;
+    for (
+        int i = row_slice.start;
+        is_row_reversed ? (i > row_slice.stop) : (i < row_slice.stop);
+        i += row_slice.step
+    )
+    {
+        int jj = 0;
+        for (
+            int j = col_slice.start;
+            is_col_reversed ? (j > col_slice.stop) : (j < col_slice.stop);
+            j += col_slice.step
+        )
+        {
+            adj_m.data[i][j] += adj_ret.data[ii][jj];
+            ++jj;
+        }
+
+        assert(jj == ColSliceLength);
+        ++ii;
+    }
+
+    assert(ii == RowSliceLength);
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE void adj_outer(const vec_t<Rows,Type>& a, const vec_t<Cols,Type>& b, vec_t<Rows,Type>& adj_a, vec_t<Cols,Type>& adj_b, const mat_t<Rows,Cols,Type>& adj_ret)
 {
@@ -1503,6 +3263,23 @@ inline CUDA_CALLABLE void adj_add(const mat_t<Rows,Cols,Type>& a, const mat_t<Ro
     }
 }
 
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_add(
+    Type a, const mat_t<Rows,Cols,Type>& b,
+    Type& adj_a, mat_t<Rows,Cols,Type>& adj_b,
+    const mat_t<Rows,Cols,Type>& adj_ret
+)
+{
+    for (unsigned i=0; i < Rows; ++i)
+    {
+        for (unsigned j=0; j < Cols; ++j)
+        {
+            adj_a += adj_ret.data[i][j];
+            adj_b.data[i][j] += adj_ret.data[i][j];
+        }
+    }
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE void adj_sub(const mat_t<Rows,Cols,Type>& a, const mat_t<Rows,Cols,Type>& b, mat_t<Rows,Cols,Type>& adj_a, mat_t<Rows,Cols,Type>& adj_b, const mat_t<Rows,Cols,Type>& adj_ret)
 {
@@ -1516,6 +3293,23 @@ inline CUDA_CALLABLE void adj_sub(const mat_t<Rows,Cols,Type>& a, const mat_t<Ro
     }
 }
 
+template<unsigned Rows, unsigned Cols, typename Type>
+inline CUDA_CALLABLE void adj_sub(
+    Type a, const mat_t<Rows,Cols,Type>& b,
+    Type& adj_a, mat_t<Rows,Cols,Type>& adj_b,
+    const mat_t<Rows,Cols,Type>& adj_ret
+)
+{
+    for (unsigned i=0; i < Rows; ++i)
+    {
+        for (unsigned j=0; j < Cols; ++j)
+        {
+            adj_a += adj_ret.data[i][j];
+            adj_b.data[i][j] -= adj_ret.data[i][j];
+        }
+    }
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE void adj_div(const mat_t<Rows,Cols,Type>& a, Type s, mat_t<Rows,Cols,Type>& adj_a, Type& adj_s, const mat_t<Rows,Cols,Type>& adj_ret)
 {