arraykit 0.10.0__cp313-cp313-win_amd64.whl

arraykit/tri_map.h

@@ -0,0 +1,8 @@
+# ifndef ARRAYKIT_SRC_TRI_MAP_H_
+# define ARRAYKIT_SRC_TRI_MAP_H_
+
+# include "Python.h"
+
+extern PyTypeObject TriMapType;
+
+# endif /* ARRAYKIT_SRC_TRI_MAP_H_ */

arraykit/utilities.h

@@ -0,0 +1,321 @@
+#ifndef ARRAYKIT_SRC_UTILITIES_H_
+#define ARRAYKIT_SRC_UTILITIES_H_
+
+# include "Python.h"
+# include "stdbool.h"
+
+# define NO_IMPORT_ARRAY
+# define PY_ARRAY_UNIQUE_SYMBOL AK_ARRAY_API
+# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+
+# include "numpy/arrayobject.h"
+
+static const size_t UCS4_SIZE = sizeof(Py_UCS4);
+
+//------------------------------------------------------------------------------
+// Macros
+//------------------------------------------------------------------------------
+
+// Given a PyObject, raise if not an array.
+# define AK_CHECK_NUMPY_ARRAY(O)                 \
+    if (!PyArray_Check(O)) {                     \
+        return PyErr_Format(PyExc_TypeError,     \
+                "Expected NumPy array, not %s.", \
+                Py_TYPE(O)->tp_name);            \
+    }
+
+// Given a PyObject, raise if not an array or is not one or two dimensional.
+# define AK_CHECK_NUMPY_ARRAY_1D_2D(O)                    \
+    do {                                                  \
+        AK_CHECK_NUMPY_ARRAY(O)                           \
+        int ndim = PyArray_NDIM((PyArrayObject *)O);      \
+        if (ndim != 1 && ndim != 2) {                     \
+            return PyErr_Format(PyExc_NotImplementedError,\
+                    "Expected 1D or 2D array, not %i.",   \
+                    ndim);                                \
+        }                                                 \
+    } 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)
+
+# if defined __GNUC__ || defined __clang__
+# define AK_LIKELY(X) __builtin_expect(!!(X), 1)
+# define AK_UNLIKELY(X) __builtin_expect(!!(X), 0)
+# else
+# define AK_LIKELY(X) (!!(X))
+# define AK_UNLIKELY(X) (!!(X))
+# endif
+
+// Placeholder of not implemented pathways / debugging.
+# define AK_NOT_IMPLEMENTED(msg)                        \
+    do {                                                \
+        PyErr_SetString(PyExc_NotImplementedError, msg);\
+        return NULL;                                    \
+    } while (0)
+
+# define _AK_DEBUG_BEGIN() \
+    do {                   \
+        fprintf(stderr, "--- %s: %i: %s: ", __FILE__, __LINE__, __FUNCTION__);
+
+# define _AK_DEBUG_END()       \
+        fprintf(stderr, "\n"); \
+        fflush(stderr);        \
+    } while (0)
+
+# define AK_DEBUG(msg)          \
+    _AK_DEBUG_BEGIN();          \
+        fprintf(stderr, #msg);  \
+    _AK_DEBUG_END()
+
+# define AK_DEBUG_MSG_OBJ(msg, obj)     \
+    _AK_DEBUG_BEGIN();                  \
+        fprintf(stderr, #msg " ");      \
+        PyObject_Print(obj, stderr, 0); \
+    _AK_DEBUG_END()
+
+# define AK_DEBUG_MSG_REFCNT(msg, obj)     \
+    _AK_DEBUG_BEGIN();                  \
+        fprintf(stderr, #msg " ref count: ");      \
+        PyObject_Print(PyLong_FromSsize_t(Py_REFCNT((PyObject*)obj)), stderr, 0); \
+    _AK_DEBUG_END()
+
+# define AK_DEBUG_OBJ(obj)              \
+    _AK_DEBUG_BEGIN();                  \
+        fprintf(stderr, #obj " = ");    \
+        PyObject_Print(obj, stderr, 0); \
+    _AK_DEBUG_END()
+
+// Takes and returns a PyArrayObject, optionally copying a mutable array and setting it as immutable
+static inline PyArrayObject *
+AK_immutable_filter(PyArrayObject *a)
+{
+    // https://numpy.org/devdocs/reference/c-api/array.html#array-flags
+    if (PyArray_FLAGS(a) & NPY_ARRAY_WRITEABLE) {
+        if ((a = (PyArrayObject *)PyArray_NewCopy(a, NPY_ANYORDER))) {
+            PyArray_CLEARFLAGS(a, NPY_ARRAY_WRITEABLE);
+        }
+        return a;
+    }
+    Py_INCREF(a);
+    return a;
+}
+
+// Returns NULL on error.
+static inline PyArray_Descr *
+AK_resolve_dtype(PyArray_Descr *d1, PyArray_Descr *d2)
+{
+    if (PyArray_EquivTypes(d1, d2)) {
+        Py_INCREF(d1);
+        return d1;
+    }
+    if (PyDataType_ISOBJECT(d1) || PyDataType_ISOBJECT(d2)
+        || PyDataType_ISBOOL(d1) || PyDataType_ISBOOL(d2)
+        || (PyDataType_ISSTRING(d1) != PyDataType_ISSTRING(d2))
+        || ((PyDataType_ISDATETIME(d1) || PyDataType_ISDATETIME(d2))
+            // PyDataType_ISDATETIME matches NPY_DATETIME or NPY_TIMEDELTA, so
+            // we need to make sure we didn't get one of each:
+            && !PyArray_EquivTypenums(d1->type_num, d2->type_num)))
+    {
+        return PyArray_DescrFromType(NPY_OBJECT);
+    }
+    PyArray_Descr *d = PyArray_PromoteTypes(d1, d2);
+    if (!d) {
+        PyErr_Clear();
+        return PyArray_DescrFromType(NPY_OBJECT);
+    }
+    return d;
+}
+
+// Returns NULL on error. Returns a new reference.
+static inline PyObject *
+AK_build_pair_ssize_t(Py_ssize_t a, Py_ssize_t b)
+{
+    PyObject* t = PyTuple_New(2);
+    if (t == NULL) {
+        return NULL;
+    }
+    PyObject* py_a = PyLong_FromSsize_t(a);
+    if (py_a == NULL) {
+        Py_DECREF(t);
+        return NULL;
+    }
+    PyObject* py_b = PyLong_FromSsize_t(b);
+    if (py_b == NULL) {
+        Py_DECREF(t);
+        Py_DECREF(py_a);
+        return NULL;
+    }
+    // steals refs
+    PyTuple_SET_ITEM(t, 0, py_a);
+    PyTuple_SET_ITEM(t, 1, py_b);
+    return t;
+}
+
+// Returns a new ref; returns NULL on error. Any start or stop less than 0 will be set to NULL.
+static inline PyObject *
+AK_build_slice(Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step)
+{
+    PyObject* py_start = NULL;
+    PyObject* py_stop = NULL;
+    PyObject* py_step = NULL;
+
+    if (start >= 0) {
+        py_start = PyLong_FromSsize_t(start);
+        if (py_start == NULL) {return NULL;}
+    }
+    if (stop >= 0) {
+        py_stop = PyLong_FromSsize_t(stop);
+        if (py_stop == NULL) {return NULL;}
+    }
+    // do not set a step if not necessary
+    if (step != 0 && step != 1) {
+        py_step = PyLong_FromSsize_t(step);
+        if (py_step == NULL) {return NULL;}
+    }
+
+    // might be NULL, let return
+    PyObject* new = PySlice_New(py_start, py_stop, py_step);
+
+    Py_XDECREF(py_start);
+    Py_XDECREF(py_stop);
+    Py_XDECREF(py_step);
+
+    return new;
+}
+
+// Utility function for converting slices; returns NULL on error; returns a new reference.
+static inline PyObject *
+AK_slice_to_ascending_slice(PyObject* slice, Py_ssize_t size)
+{
+    Py_ssize_t step_count = -1;
+    Py_ssize_t start = 0;
+    Py_ssize_t stop = 0;
+    Py_ssize_t step = 0;
+
+    if (PySlice_Unpack(slice, &start, &stop, &step)) {
+        return NULL;
+    }
+    if (step > 0) {
+        Py_INCREF(slice);
+        return slice;
+    }
+    step_count = PySlice_AdjustIndices(
+            size,
+            &start,
+            &stop,
+            step);
+
+    // step will be negative; shift original start value down to find new start
+    return AK_build_slice(
+            start + (step * (step_count - 1)),
+            start + 1,
+            -step);
+}
+
+// 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) {
+    PyObject* final;
+    npy_intp count_max = PyArray_SIZE(array);
+
+    if (count_max == 0) { // return empty array
+        npy_intp dims = {count_max};
+        final = PyArray_SimpleNew(1, &dims, NPY_INT64);
+        PyArray_CLEARFLAGS((PyArrayObject*)final, NPY_ARRAY_WRITEABLE);
+        return final;
+    }
+    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
+    Py_ssize_t capacity = count_max;
+    npy_int64* indices = (npy_int64*)malloc(sizeof(npy_int64) * capacity);
+
+    NPY_BEGIN_THREADS_DEF;
+    NPY_BEGIN_THREADS;
+
+    if (PyArray_IS_C_CONTIGUOUS(array)) {
+        npy_bool* p_start = (npy_bool*)PyArray_DATA(array);
+        npy_bool* p = p_start;
+        npy_bool* p_end = p + count_max;
+        npy_bool* p_end_roll = p_end - size_div.rem;
+
+        while (p < p_end_roll) {
+            if (*(npy_uint64*)p == 0) {
+                p += 8; // no true within this 8 byte roll region
+                continue;
+            }
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+        }
+        while (p < p_end) {
+            if (*p) {indices[count++] = p - p_start;}
+            p++;
+        }
+    }
+    else {
+        npy_intp i = 0; // position within Boolean 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)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+        }
+        while (i < i_end) {
+            if (*(npy_bool*)PyArray_GETPTR1(array, i)) {indices[count++] = i;}
+            i++;
+        }
+    }
+    NPY_END_THREADS;
+
+    npy_intp dims = {count};
+    final = PyArray_SimpleNewFromData(1, &dims, NPY_INT64, (void*)indices);
+    if (!final) {
+        free(indices);
+        return NULL;
+    }
+    // This ensures that the array frees the indices array; this has been tested by calling free(indices) and observing segfault
+    PyArray_ENABLEFLAGS((PyArrayObject*)final, NPY_ARRAY_OWNDATA);
+    PyArray_CLEARFLAGS((PyArrayObject*)final, NPY_ARRAY_WRITEABLE);
+    return final;
+}
+
+#endif  /* ARRAYKIT_SRC_UTILITIES_H_ */

arraykit-0.10.0.dist-info/LICENSE.txt

@@ -0,0 +1,37 @@
+
+License
+=============
+
+MIT License
+
+Copyright (c) 2012-2022 Christopher Ariza, Research Affiliates, others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+IN NO EVENT SHALL RESEARCH AFFILATES, LLC (“RA”) BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST
+PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
+RA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+RA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
+SOFTWARE AND ACCOMPANYING DOCUMENTATION OR TEXT, IF ANY, PROVIDED HEREUNDER IS
+PROVIDED "AS IS". RA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
+ENHANCEMENTS, OR MODIFICATIONS.
+

arraykit-0.10.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: arraykit
+Version: 0.10.0
+Summary: Array utilities for StaticFrame
+Home-page: https://github.com/static-frame/arraykit
+Author: Christopher Ariza, Brandt Bucher, Charles Burkland
+License: MIT
+Keywords: numpy array
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.19.5
+
+The ArrayKit library provides utilities for creating and transforming NumPy arrays, implementing performance-critical StaticFrame operations as Python C extensions.
+
+Code: https://github.com/static-frame/arraykit
+
+Packages: https://pypi.org/project/arraykit

arraykit-0.10.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+arraykit/__init__.py,sha256=8EFKJx3Va5lqt6mMH2dIkSju6zjFnNn4Bs-0hLrEr5w,1710
+arraykit/__init__.pyi,sha256=qqXGXVQapnRKukMKGZaCqm5tsTPBuS7Pxn9m_pumAVs,6423
+arraykit/_arraykit.c,sha256=l0qZWOpFM1uhu5UNUCR-qi4kd8gnaTMn5ifq2V_DyQQ,4113
+arraykit/_arraykit.cp313-win_amd64.pyd,sha256=kcO-PKvXnLUvwA-Tg-fjKMjkQEON4D7uPWqYBFyuErY,112128
+arraykit/array_go.c,sha256=u9gRnVM8AejfHq6h1_fBCOcLb_Phloi2ch1TT57yH8k,7255
+arraykit/array_go.h,sha256=D6qfN2Cb6lvb7S9lGEpKi6cOoBW86hzO1Uez4A9xhOQ,172
+arraykit/array_to_tuple.c,sha256=QcBobwzJDAiM660Y7wQ04OGZXrnda2PWMAUL6syG9Q4,7898
+arraykit/array_to_tuple.h,sha256=9OotdVKSH8_tJP2zwwhz6n3vciJsysTszG9N5lKI12w,418
+arraykit/block_index.c,sha256=Q_Vef-ysdHmV9t7BaAXJjUp-S166IXRXNqrbE_-BpkU,45754
+arraykit/block_index.h,sha256=oR-WgZsdD6Xl7HyeFcrvBJ-LtBQkcfwizVFo9SaWcKI,449
+arraykit/delimited_to_arrays.c,sha256=9v01-E0EEkBalXFsgL7rLKt5QBgCeN7QhBqGaNEuRrw,101568
+arraykit/delimited_to_arrays.h,sha256=IuXW5AUhMZ6SC5s6VaC16mIC1-4CpQks4AmCsI2W56I,527
+arraykit/methods.c,sha256=r6Gt_asknpNYY34TsT3GqmkOhMiDWcP9DHBhqjyo2X8,33431
+arraykit/methods.h,sha256=j0k5mAxhhhbyVpvv3vNAYr_sJ7D6IFRaqRYIktj9JX4,2386
+arraykit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arraykit/tri_map.c,sha256=GDlUfInfKrPQL9iBIbfhtf91ziDWR-X2gYNf8XTqfQI,52709
+arraykit/tri_map.h,sha256=8_wYUqQTM2fTkP3GSHfQB0e0O3OrUZzpKuoGUXEFCJE,168
+arraykit/utilities.h,sha256=iv_oV3YuiOrNeCgweMkOzhL3Whdn8wM6fpas9Jw-3Cg,11417
+arraykit-0.10.0.dist-info/LICENSE.txt,sha256=3t-z3TUy-ObAbtNww27zjhtD70pPtxLG-bSU0fUEk1k,1816
+arraykit-0.10.0.dist-info/METADATA,sha256=7vWktSh_QaHym0Wia6UwfWG_h9i45u8CmqP1Ojh_02E,1334
+arraykit-0.10.0.dist-info/WHEEL,sha256=4-iQBlRoDdX1wfPofc7KLWa5Cys4eZSgXs6GVU8fKlQ,101
+arraykit-0.10.0.dist-info/top_level.txt,sha256=00W90765jXl-QEGzShY2mT-haT9R5aB_MiTmxrFaBhQ,9
+arraykit-0.10.0.dist-info/RECORD,,

arraykit-0.10.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

arraykit-0.10.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+arraykit