arraykit 0.6.2__tar.gz → 0.7.0__tar.gz

{arraykit-0.6.2/arraykit.egg-info → arraykit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.6.2
+Version: 0.7.0
 Summary: Array utilities for StaticFrame
 Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland

{arraykit-0.6.2 → arraykit-0.7.0}/README.rst

@@ -37,10 +37,24 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+0.7.0
+............
+
+Added ``array2d_to_array1d()``.
+
+Added ``array2d_tuple_iter()``.
+
+
+0.6.3
+............
+
+Optimized memory allocation strategy for ``nonzero_1d()``.
+
+
 0.6.2
 ............
 
-Extended ``nonzero_1d()`` to support non-contiguous arrays,
+Extended ``nonzero_1d()`` to support non-contiguous arrays.
 
 Optimizations to ``TriMap`` when mapping to object and flexible dtypes.
 

{arraykit-0.6.2 → arraykit-0.7.0/arraykit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.6.2
+Version: 0.7.0
 Summary: Array utilities for StaticFrame
 Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland

{arraykit-0.6.2 → arraykit-0.7.0}/setup.py

@@ -5,7 +5,7 @@ from setuptools import Extension  # type: ignore
 from setuptools import setup
 from pathlib import Path
 
-AK_VERSION = '0.6.2'
+AK_VERSION = '0.7.0'
 
 def get_long_description() -> str:
     return '''The ArrayKit library provides utilities for creating and transforming NumPy arrays, implementing performance-critical StaticFrame operations as Python C extensions.

{arraykit-0.6.2 → arraykit-0.7.0}/src/__init__.py

@@ -28,4 +28,6 @@ from ._arraykit import count_iteration as count_iteration
 from ._arraykit import first_true_1d as first_true_1d
 from ._arraykit import first_true_2d as first_true_2d
 from ._arraykit import slice_to_ascending_slice as slice_to_ascending_slice
+from ._arraykit import array2d_to_array1d as array2d_to_array1d
+from ._arraykit import array2d_tuple_iter as array2d_tuple_iter
 from ._arraykit import nonzero_1d as nonzero_1d

{arraykit-0.6.2 → arraykit-0.7.0}/src/__init__.pyi

@@ -161,3 +161,5 @@ def first_true_1d(__array: np.ndarray, *, forward: bool) -> int: ...
 def first_true_2d(__array: np.ndarray, *, forward: bool, axis: int) -> np.ndarray: ...
 def nonzero_1d(__array: np.ndarray, /) -> np.ndarray: ...
 def slice_to_ascending_slice(__slice: slice, __size: int) -> slice: ...
+def array2d_to_array1d(__array: np.ndarray) -> np.ndarray: ...
+def array2d_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...

{arraykit-0.6.2 → arraykit-0.7.0}/src/_arraykit.c

@@ -37,6 +37,18 @@ const static size_t UCS4_SIZE = sizeof(Py_UCS4);
         }                                                 \
     } while (0)
 
+// Given a PyObject, raise if not an array or is not two dimensional.
+# define AK_CHECK_NUMPY_ARRAY_2D(O)                       \
+    do {                                                  \
+        AK_CHECK_NUMPY_ARRAY(O)                           \
+        int ndim = PyArray_NDIM((PyArrayObject *)O);      \
+        if (ndim != 2) {                                  \
+            return PyErr_Format(PyExc_NotImplementedError,\
+                    "Expected a 2D array, not %i.",       \
+                    ndim);                                \
+        }                                                 \
+    } while (0)
+
 // Placeholder of not implemented pathways / debugging.
 # define AK_NOT_IMPLEMENTED(msg)                        \
     do {                                                \
@@ -836,9 +848,9 @@ AK_TP_ResolveLineResetField(AK_TypeParser* tp,
 static char* TRUE_LOWER = "true";
 static char* TRUE_UPPER = "TRUE";
 
-#define ERROR_NO_DIGITS 1
-#define ERROR_OVERFLOW 2
-#define ERROR_INVALID_CHARS 3
+#define AK_ERROR_NO_DIGITS 1
+#define AK_ERROR_OVERFLOW 2
+#define AK_ERROR_INVALID_CHARS 3
 
 // Convert a Py_UCS4 array to a signed integer. Extended from pandas/_libs/src/parser/tokenizer.c. Sets `error` to values greater than 0 on error; never sets error on success.
 static inline npy_int64
@@ -866,7 +878,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
 
     // Check that there is a first digit.
     if (!AK_is_digit(*p)) {
-        *error = ERROR_NO_DIGITS;
+        *error = AK_ERROR_NO_DIGITS;
         return 0;
     }
     if (isneg) {
@@ -891,7 +903,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                     if (p >= end) return number;
                     d = *p;
                 } else {
-                    *error = ERROR_OVERFLOW;
+                    *error = AK_ERROR_OVERFLOW;
                     return 0;
                 }
             }
@@ -904,7 +916,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                     if (p >= end) return number;
                     d = *p;
                 } else {
-                    *error = ERROR_OVERFLOW;
+                    *error = AK_ERROR_OVERFLOW;
                     return 0;
                 }
             }
@@ -931,7 +943,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                     if (p >= end) return number;
                     d = *p;
                 } else {
-                    *error = ERROR_OVERFLOW;
+                    *error = AK_ERROR_OVERFLOW;
                     return 0;
                 }
             }
@@ -944,7 +956,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                     if (p >= end) return number;
                     d = *p;
                 } else {
-                    *error = ERROR_OVERFLOW;
+                    *error = AK_ERROR_OVERFLOW;
                     return 0;
                 }
             }
@@ -952,7 +964,7 @@ AK_UCS4_to_int64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
     }
     while (p < end) {
         if (!AK_is_space(*p)) {
-            *error = ERROR_INVALID_CHARS;
+            *error = AK_ERROR_INVALID_CHARS;
             return 0;
         }
         p++;
@@ -975,7 +987,7 @@ AK_UCS4_to_uint64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
         if (p >= end) return number;
     }
     if (*p == '-') {
-        *error = ERROR_INVALID_CHARS;
+        *error = AK_ERROR_INVALID_CHARS;
         return 0;
     } else if (*p == '+') {
         p++;
@@ -984,7 +996,7 @@ AK_UCS4_to_uint64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
 
     // Check that there is a first digit.
     if (!AK_is_digit(*p)) {
-        *error = ERROR_NO_DIGITS;
+        *error = AK_ERROR_NO_DIGITS;
         return 0;
     }
     // If number is less than pre_max, at least one more digit can be processed without overflowing.
@@ -1006,7 +1018,7 @@ AK_UCS4_to_uint64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                 if (p >= end) return number;
                 d = *p;
             } else {
-                *error = ERROR_OVERFLOW;
+                *error = AK_ERROR_OVERFLOW;
                 return 0;
             }
         }
@@ -1019,14 +1031,14 @@ AK_UCS4_to_uint64(Py_UCS4 *p_item, Py_UCS4 *end, int *error, char tsep)
                 if (p >= end) return number;
                 d = *p;
             } else {
-                *error = ERROR_OVERFLOW;
+                *error = AK_ERROR_OVERFLOW;
                 return 0;
             }
         }
     }
     while (p < end) {
         if (!AK_is_space(*p)) {
-            *error = ERROR_INVALID_CHARS;
+            *error = AK_ERROR_INVALID_CHARS;
             return 0;
         }
         p++;
@@ -3511,6 +3523,167 @@ array_deepcopy(PyObject *m, PyObject *args, PyObject *kwargs)
     return AK_ArrayDeepCopy(m, (PyArrayObject*)array, memo);
 }
 
+//------------------------------------------------------------------------------
+// Given a 2D array, return a 1D object array of tuples.
+static PyObject *
+array2d_to_array1d(PyObject *Py_UNUSED(m), PyObject *a)
+{
+    AK_CHECK_NUMPY_ARRAY_2D(a);
+    PyArrayObject *input_array = (PyArrayObject *)a;
+
+    npy_intp num_rows = PyArray_DIM(input_array, 0);
+    npy_intp num_cols = PyArray_DIM(input_array, 1);
+
+    npy_intp dims[] = {num_rows};
+    // NOTE: this initializes values to NULL, not None
+    PyObject* output = PyArray_SimpleNew(1, dims, NPY_OBJECT);
+    if (output == NULL) {
+        return NULL;
+    }
+
+    PyObject** output_data = (PyObject**)PyArray_DATA((PyArrayObject*)output);
+    PyObject** p = output_data;
+    PyObject** p_end = p + num_rows;
+    npy_intp i = 0;
+    npy_intp j;
+    PyObject* tuple;
+    PyObject* item;
+
+    while (p < p_end) {
+        tuple = PyTuple_New(num_cols);
+        if (tuple == NULL) {
+            goto error;
+        }
+        for (j = 0; j < num_cols; ++j) {
+            // cannot assume input_array is contiguous
+            item = PyArray_ToScalar(PyArray_GETPTR2(input_array, i, j), input_array);
+            if (item == NULL) {
+                Py_DECREF(tuple);
+                goto error;
+            }
+            PyTuple_SET_ITEM(tuple, j, item); // steals reference to item
+        }
+        *p++ = tuple; // assign with new ref, no incr needed
+        i++;
+    }
+    PyArray_CLEARFLAGS((PyArrayObject *)output, NPY_ARRAY_WRITEABLE);
+    return output;
+error:
+    p = output_data;
+    p_end = p + num_rows;
+    while (p < p_end) { // decref all tuples within array
+        Py_XDECREF(*p++); // xdec as might be NULL
+    }
+    Py_DECREF(output);
+    return NULL;
+}
+
+//------------------------------------------------------------------------------
+// Array2DTuple Iterator
+
+static PyTypeObject A2DTupleType;
+
+typedef struct A2DTupleObject {
+    PyObject_HEAD
+    PyArrayObject* array;
+    npy_intp num_rows;
+    npy_intp num_cols;
+    Py_ssize_t pos; // current index state, mutated in-place
+} A2DTupleObject;
+
+static PyObject *
+A2DTuple_new(PyArrayObject* array,
+        npy_intp num_rows,
+        npy_intp num_cols) {
+    A2DTupleObject* a2dt = PyObject_New(A2DTupleObject, &A2DTupleType);
+    if (!a2dt) {
+        return NULL;
+    }
+    Py_INCREF((PyObject*)array);
+    a2dt->array = array;
+    a2dt->num_rows = num_rows;
+    a2dt->num_cols = num_cols;
+    a2dt->pos = 0;
+    return (PyObject *)a2dt;
+}
+
+static void
+A2DTuple_dealloc(A2DTupleObject *self) {
+    Py_DECREF((PyObject*)self->array);
+    PyObject_Del((PyObject*)self);
+}
+
+static PyObject*
+A2DTuple_iter(A2DTupleObject *self) {
+    Py_INCREF(self);
+    return (PyObject*)self;
+}
+
+static PyObject *
+A2DTuple_iternext(A2DTupleObject *self) {
+    Py_ssize_t i = self->pos;
+    if (i < self->num_rows) {
+        npy_intp num_cols = self->num_cols;
+        PyArrayObject* array = self->array;
+        PyObject* tuple = PyTuple_New(num_cols);
+        PyObject* item;
+        if (tuple == NULL) {
+            return NULL;
+        }
+        for (npy_intp j = 0; j < num_cols; ++j) {
+            // cannot assume array is contiguous
+            item = PyArray_ToScalar(PyArray_GETPTR2(array, i, j), array);
+            if (item == NULL) {
+                Py_DECREF(tuple);
+                return NULL;
+            }
+            PyTuple_SET_ITEM(tuple, j, item); // steals reference to item
+        }
+        self->pos++;
+        return tuple;
+    }
+    return NULL;
+}
+
+// static PyObject *
+// A2DTuple_reversed(A2DTupleObject *self) {
+//     return A2DTuple_new(self->bi, !self->reversed);
+// }
+
+static PyObject *
+A2DTuple_length_hint(A2DTupleObject *self) {
+    Py_ssize_t len = Py_MAX(0, self->num_rows - self->pos);
+    return PyLong_FromSsize_t(len);
+}
+
+static PyMethodDef A2DTuple_methods[] = {
+    {"__length_hint__", (PyCFunction)A2DTuple_length_hint, METH_NOARGS, NULL},
+    // {"__reversed__", (PyCFunction)A2DTuple_reversed, METH_NOARGS, NULL},
+    {NULL},
+};
+
+static PyTypeObject A2DTupleType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_basicsize = sizeof(A2DTupleObject),
+    .tp_dealloc = (destructor) A2DTuple_dealloc,
+    .tp_iter = (getiterfunc) A2DTuple_iter,
+    .tp_iternext = (iternextfunc) A2DTuple_iternext,
+    .tp_methods = A2DTuple_methods,
+    .tp_name = "arraykit.A2DTupleIterator",
+};
+
+// Given a 2D array, return an iterator of row tuples.
+static PyObject *
+array2d_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
+{
+    AK_CHECK_NUMPY_ARRAY_2D(a);
+    PyArrayObject* array = (PyArrayObject *)a;
+    npy_intp num_rows = PyArray_DIM(array, 0);
+    npy_intp num_cols = PyArray_DIM(array, 1);
+    return A2DTuple_new(array, num_rows, num_cols);
+}
+
+
 //------------------------------------------------------------------------------
 // type resolution
 
@@ -3535,32 +3708,9 @@ resolve_dtype_iter(PyObject *Py_UNUSED(m), PyObject *arg) {
 //------------------------------------------------------------------------------
 // general utility
 
-#define NONZERO_APPEND_INDEX_RELATIVE {                                      \
-    if (AK_UNLIKELY(count == capacity)) {                                    \
-        capacity <<= 1;                                                      \
-        indices = (npy_int64*)realloc(indices, sizeof(npy_int64) * capacity);\
-        if (indices == NULL) {                                               \
-            return NULL;                                                     \
-        }                                                                    \
-    }                                                                        \
-    indices[count++] = p - p_start;                                          \
-}                                                                            \
-
-#define NONZERO_APPEND_INDEX_ABSOLUTE {                                      \
-    if (AK_UNLIKELY(count == capacity)) {                                    \
-        capacity <<= 1;                                                      \
-        indices = (npy_int64*)realloc(indices, sizeof(npy_int64) * capacity);\
-        if (indices == NULL) {                                               \
-            return NULL;                                                     \
-        }                                                                    \
-    }                                                                        \
-    indices[count++] = i;                                                    \
-}                                                                            \
-
-// Given a Boolean, contiguous 1D array, return the index positions in an int64 array. Through experimentation it has been verified that doing full-size allocation of memory does not permit outperforming NumPy at 10_000_000 scale; but doing less optimizations does help. Using bit masks does not improve perforamnce over pointer arithmetic. Prescanning for all empty is very effective. Note that NumPy befits from first counting the nonzeros, then allocating only enough data for the expexted number.
+// Given a Boolean, contiguous 1D array, return the index positions in an int64 array. Through experimentation it has been verified that doing full-size allocation of memory provides the best performance at all scales. Using NpyIter, or using, bit masks does not improve performance over pointer arithmetic. Prescanning for all empty is very effective. Note that NumPy benefits from first counting the nonzeros, then allocating only enough data for the expexted number of indices.
 static inline PyObject*
 AK_nonzero_1d(PyArrayObject* array) {
-    // the maxiumum number of indices we could return is the size of the array; if this is under a certain number, probably better to just allocate that rather than reallocate
     PyObject* final;
     npy_intp count_max = PyArray_SIZE(array);
 
@@ -3573,8 +3723,8 @@ AK_nonzero_1d(PyArrayObject* array) {
     lldiv_t size_div = lldiv((long long)count_max, 8); // quot, rem
 
     Py_ssize_t count = 0;
-    // the maximum number of collected integers is equal to or less than count_max; for small count_max, we can just set that value; for large size, we set it to half the size
-    Py_ssize_t capacity = count_max < 1024 ? count_max : count_max / 8;
+    // the maximum number of collected integers is equal to or less than count_max
+    Py_ssize_t capacity = count_max;
     npy_int64* indices = (npy_int64*)malloc(sizeof(npy_int64) * capacity);
 
     NPY_BEGIN_THREADS_DEF;
@@ -3591,25 +3741,25 @@ AK_nonzero_1d(PyArrayObject* array) {
                 p += 8; // no true within this 8 byte roll region
                 continue;
             }
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
         }
         while (p < p_end) {
-            if (*p) {NONZERO_APPEND_INDEX_RELATIVE;}
+            if (*p) {indices[count++] = p - p_start;}
             p++;
         }
     }
@@ -3618,25 +3768,25 @@ AK_nonzero_1d(PyArrayObject* array) {
         npy_intp i_end = count_max;
         npy_intp i_end_roll = count_max - size_div.rem;
         while (i < i_end_roll) {
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
         }
         while (i < i_end) {
-            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {NONZERO_APPEND_INDEX_ABSOLUTE;}
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
             i++;
         }
     }
@@ -3653,8 +3803,6 @@ AK_nonzero_1d(PyArrayObject* array) {
     PyArray_CLEARFLAGS((PyArrayObject*)final, NPY_ARRAY_WRITEABLE);
     return final;
 }
-#undef NONZERO_APPEND_INDEX_RELATIVE
-#undef NONZERO_APPEND_INDEX_ABSOLUTE
 
 static PyObject*
 nonzero_1d(PyObject *Py_UNUSED(m), PyObject *a) {
@@ -5969,7 +6117,6 @@ TriMap_dealloc(TriMapObject *self) {
     if (self->many_from != NULL) {
         // decref all arrays before freeing
         for (Py_ssize_t i = 0; i < self->many_count; i++) {
-            // NOTE: using dot to get to pointer?
             Py_DECREF((PyObject*)self->many_from[i].dst);
         }
         PyMem_Free(self->many_from);
@@ -6102,14 +6249,12 @@ TriMap_register_unmatched_dst(TriMapObject *self) {
             return NULL;
         }
         // derive indices for unmatched locations, call each with register_one
-        // PyObject* nonzero = PyArray_Nonzero(dst_unmatched);
         PyArrayObject* indices = (PyArrayObject*)AK_nonzero_1d(dst_unmatched);
         if (indices == NULL) {
             Py_DECREF((PyObject*)dst_unmatched);
             return NULL;
         }
         // borrow ref to array in 1-element tuple
-        // PyArrayObject *indices = (PyArrayObject*)PyTuple_GET_ITEM(nonzero, 0);
         npy_int64 *index_data = (npy_int64 *)PyArray_DATA(indices);
         npy_intp index_len = PyArray_SIZE(indices);
 
@@ -7286,6 +7431,8 @@ static PyMethodDef arraykit_methods[] =  {
             (PyCFunction)array_deepcopy,
             METH_VARARGS | METH_KEYWORDS,
             NULL},
+    {"array2d_to_array1d", array2d_to_array1d, METH_O, NULL},
+    {"array2d_tuple_iter", array2d_tuple_iter, METH_O, NULL},
     {"resolve_dtype", resolve_dtype, METH_VARARGS, NULL},
     {"resolve_dtype_iter", resolve_dtype_iter, METH_O, NULL},
     {"first_true_1d",

{arraykit-0.6.2 → arraykit-0.7.0}/test/test_util.py

@@ -22,6 +22,8 @@ from arraykit import count_iteration
 from arraykit import first_true_1d
 from arraykit import first_true_2d
 from arraykit import slice_to_ascending_slice
+from arraykit import array2d_to_array1d
+from arraykit import array2d_tuple_iter
 
 from performance.reference.util import get_new_indexers_and_screen_ak as get_new_indexers_and_screen_full
 from arraykit import get_new_indexers_and_screen
@@ -283,6 +285,93 @@ class TestUnit(unittest.TestCase):
         with self.assertRaises(TypeError):
             a2 = array_deepcopy(a1, ())
 
+    #---------------------------------------------------------------------------
+    def test_array2d_to_array1d_dummy(self) -> None:
+        a1 = np.arange(10)
+        with self.assertRaises(NotImplementedError):
+            # 1 dimensional
+            _ = array2d_to_array1d(a1)
+
+    def test_array2d_to_array1d_b(self) -> None:
+        a1 = np.arange(10, dtype=np.int64).reshape(5, 2)
+        result = array2d_to_array1d(a1)
+        assert isinstance(result[0], tuple)
+        assert result[0] == (0, 1)
+        self.assertIs(type(result[0][0]), np.int64)
+        self.assertFalse(result.flags.writeable)
+        self.assertEqual(tuple(result), ((0, 1), (2, 3), (4, 5), (6, 7), (8, 9)))
+
+
+    def test_array2d_to_array1d_c(self) -> None:
+        a1 = np.array([["a", "b"], ["ccc", "ddd"], ["ee", "ff"]])
+        a2 = array2d_to_array1d(a1)
+        self.assertEqual(a2.tolist(), [('a', 'b'), ('ccc', 'ddd'), ('ee', 'ff')])
+
+    def test_array2d_to_array1d_d(self) -> None:
+        a1 = np.array([[3, 5], [10, 20], [7, 2]], dtype=np.uint8)
+        a2 = array2d_to_array1d(a1)
+        self.assertEqual(a2.tolist(), [(3, 5), (10, 20), (7, 2)])
+        self.assertIs(type(a2[0][0]), np.uint8)
+
+    def test_array2d_to_array1d_e(self) -> None:
+        a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
+        result = array2d_to_array1d(a1)
+        self.assertEqual(result.tolist(), [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
+
+    #---------------------------------------------------------------------------
+    def test_array2d_tuple_iter_a(self) -> None:
+        a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
+        result = list(array2d_tuple_iter(a1))
+        self.assertEqual(len(result), 4)
+        self.assertEqual(result, [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
+
+    def test_array2d_tuple_iter_b(self) -> None:
+        a1 = np.arange(20, dtype=np.int64).reshape(10, 2)
+        result = list(array2d_tuple_iter(a1))
+        self.assertEqual(result, [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11), (12, 13), (14, 15), (16, 17), (18, 19)])
+
+    def test_array2d_tuple_iter_c(self) -> None:
+        a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
+        it = array2d_tuple_iter(a1)
+        self.assertEqual(it.__length_hint__(), 3)
+        self.assertEqual(next(it), ('aaa', 'bb'))
+        self.assertEqual(it.__length_hint__(), 2)
+        self.assertEqual(next(it), ('c', 'dd'))
+        self.assertEqual(it.__length_hint__(), 1)
+        self.assertEqual(next(it), ('ee', 'fffff'))
+        self.assertEqual(it.__length_hint__(), 0)
+        with self.assertRaises(StopIteration):
+            next(it)
+
+    def test_array2d_tuple_iter_d(self) -> None:
+        a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
+        it = array2d_tuple_iter(a1)
+        # __reversed__ not implemented
+        with self.assertRaises(TypeError):
+            reversed(it)
+
+    def test_array2d_tuple_iter_e(self) -> None:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        it = array2d_tuple_iter(a1)
+        del a1
+        self.assertEqual(list(it), [(None, 'bb'), (None, 'dd'), (3, None)])
+
+    def test_array2d_tuple_iter_f(self) -> None:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        it1 = array2d_tuple_iter(a1)
+        del a1
+        it2 = iter(it1)
+        self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
+        self.assertEqual(list(it2), []) # expected behavior
+
+    def test_array2d_tuple_iter_g(self) -> None:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        it1 = array2d_tuple_iter(a1)
+        it2 = array2d_tuple_iter(a1)
+        del a1
+        self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
+        self.assertEqual(list(it2), [(None, 'bb'), (None, 'dd'), (3, None)])
+
     #---------------------------------------------------------------------------
 
     def test_isna_element_a(self) -> None: