numpy-quaddtype 0.1.0__tar.gz → 0.2.1__tar.gz

numpy_quaddtype-0.2.1/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2022, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials provided
+       with the distribution.
+
+    * Neither the name of the NumPy Developers nor the names of any
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

numpy_quaddtype-0.2.1/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: numpy_quaddtype
+Version: 0.2.1
+Summary: Quad (128-bit) float dtype for numpy
+Author-Email: Swayam Singh <singhswayam008@gmail.com>
+License: Copyright (c) 2022, NumPy Developers.
+         All rights reserved.
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions are
+         met:
+         
+             * Redistributions of source code must retain the above copyright
+                notice, this list of conditions and the following disclaimer.
+         
+             * Redistributions in binary form must reproduce the above
+                copyright notice, this list of conditions and the following
+                disclaimer in the documentation and/or other materials provided
+                with the distribution.
+         
+             * Neither the name of the NumPy Developers nor the names of any
+                contributors may be used to endorse or promote products derived
+                from this software without specific prior written permission.
+         
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+         OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+         SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+         LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+         DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+         THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+         (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+Requires-Python: >=3.10.0
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-run-parallel; extra == "test"
+Description-Content-Type: text/markdown
+
+# Numpy-QuadDType
+
+A cross-platform Quad (128-bit) float Data-Type for NumPy.
+
+## Installation
+
+```bash
+pip install numpy
+pip install numpy-quaddtype
+```
+
+## Usage
+
+```python
+import numpy as np
+from numpy_quaddtype import QuadPrecDType, QuadPrecision
+
+# using sleef backend (default)
+np.array([1,2,3], dtype=QuadPrecDType())
+np.array([1,2,3], dtype=QuadPrecDType("sleef"))
+
+# using longdouble backend
+np.array([1,2,3], dtype=QuadPrecDType("longdouble"))
+```
+
+## Installation from source
+
+#### Prerequisites
+
+- **gcc/clang**
+- **CMake** (≥3.15)
+- **Python 3.10+**
+- **Git**
+
+### Linux/Unix/macOS
+
+Building the `numpy-quaddtype` package:
+
+```bash
+# setup the virtual env
+python3 -m venv temp
+source temp/bin/activate
+
+# Install the package
+pip install numpy pytest
+
+# To build without QBLAS (default for MSVC)
+# export CFLAGS="-DDISABLE_QUADBLAS"
+# export CXXFLAGS="-DDISABLE_QUADBLAS"
+
+python -m pip install . -v
+
+# Run the tests
+cd ..
+python -m pytest
+```
+
+### Windows
+
+#### Prerequisites
+
+- **Visual Studio 2017 or later** (with MSVC compiler)
+- **CMake** (≥3.15)
+- **Python 3.10+**
+- **Git**
+
+#### Step-by-Step Installation
+
+1. **Setup Development Environment**
+
+   Open a **Developer Command Prompt for VS** or **Developer PowerShell for VS** to ensure MSVC is properly configured.
+
+2. **Setup Python Environment**
+
+   ```powershell
+   # Create and activate virtual environment
+   python -m venv numpy_quad_env
+   .\numpy_quad_env\Scripts\Activate.ps1
+
+   # Install build dependencies
+   pip install -U pip
+   pip install numpy pytest ninja meson
+   ```
+
+3. **Set Environment Variables**
+
+   ```powershell
+   # Note: QBLAS is disabled on Windows due to MSVC compatibility issues
+   $env:CFLAGS = "/DDISABLE_QUADBLAS"
+   $env:CXXFLAGS = "/DDISABLE_QUADBLAS"
+   ```
+
+4. **Build and Install numpy-quaddtype**
+
+   ```powershell
+   # Build and install the package
+   python -m pip install . -v
+   ```
+
+5. **Test Installation**
+
+   ```powershell
+   # Run tests
+   pytest -s tests/
+   ```
+
+6. **QBLAS Disabled**: QuadBLAS optimization is automatically disabled on Windows builds due to MSVC compatibility issues. This is handled by the `-DDISABLE_QUADBLAS` compiler flag.
+
+7. **Visual Studio Version**: The instructions assume Visual Studio 2022. For other versions, adjust the generator string:
+
+   - VS 2019: `"Visual Studio 16 2019"`
+   - VS 2017: `"Visual Studio 15 2017"`
+
+8. **Architecture**: The instructions are for x64. For x86 builds, change `-A x64` to `-A Win32`.

numpy_quaddtype-0.2.1/README.md

@@ -0,0 +1,114 @@
+# Numpy-QuadDType
+
+A cross-platform Quad (128-bit) float Data-Type for NumPy.
+
+## Installation
+
+```bash
+pip install numpy
+pip install numpy-quaddtype
+```
+
+## Usage
+
+```python
+import numpy as np
+from numpy_quaddtype import QuadPrecDType, QuadPrecision
+
+# using sleef backend (default)
+np.array([1,2,3], dtype=QuadPrecDType())
+np.array([1,2,3], dtype=QuadPrecDType("sleef"))
+
+# using longdouble backend
+np.array([1,2,3], dtype=QuadPrecDType("longdouble"))
+```
+
+## Installation from source
+
+#### Prerequisites
+
+- **gcc/clang**
+- **CMake** (≥3.15)
+- **Python 3.10+**
+- **Git**
+
+### Linux/Unix/macOS
+
+Building the `numpy-quaddtype` package:
+
+```bash
+# setup the virtual env
+python3 -m venv temp
+source temp/bin/activate
+
+# Install the package
+pip install numpy pytest
+
+# To build without QBLAS (default for MSVC)
+# export CFLAGS="-DDISABLE_QUADBLAS"
+# export CXXFLAGS="-DDISABLE_QUADBLAS"
+
+python -m pip install . -v
+
+# Run the tests
+cd ..
+python -m pytest
+```
+
+### Windows
+
+#### Prerequisites
+
+- **Visual Studio 2017 or later** (with MSVC compiler)
+- **CMake** (≥3.15)
+- **Python 3.10+**
+- **Git**
+
+#### Step-by-Step Installation
+
+1. **Setup Development Environment**
+
+   Open a **Developer Command Prompt for VS** or **Developer PowerShell for VS** to ensure MSVC is properly configured.
+
+2. **Setup Python Environment**
+
+   ```powershell
+   # Create and activate virtual environment
+   python -m venv numpy_quad_env
+   .\numpy_quad_env\Scripts\Activate.ps1
+
+   # Install build dependencies
+   pip install -U pip
+   pip install numpy pytest ninja meson
+   ```
+
+3. **Set Environment Variables**
+
+   ```powershell
+   # Note: QBLAS is disabled on Windows due to MSVC compatibility issues
+   $env:CFLAGS = "/DDISABLE_QUADBLAS"
+   $env:CXXFLAGS = "/DDISABLE_QUADBLAS"
+   ```
+
+4. **Build and Install numpy-quaddtype**
+
+   ```powershell
+   # Build and install the package
+   python -m pip install . -v
+   ```
+
+5. **Test Installation**
+
+   ```powershell
+   # Run tests
+   pytest -s tests/
+   ```
+
+6. **QBLAS Disabled**: QuadBLAS optimization is automatically disabled on Windows builds due to MSVC compatibility issues. This is handled by the `-DDISABLE_QUADBLAS` compiler flag.
+
+7. **Visual Studio Version**: The instructions assume Visual Studio 2022. For other versions, adjust the generator string:
+
+   - VS 2019: `"Visual Studio 16 2019"`
+   - VS 2017: `"Visual Studio 15 2017"`
+
+8. **Architecture**: The instructions are for x64. For x86 builds, change `-A x64` to `-A Win32`.

{numpy_quaddtype-0.1.0 → numpy_quaddtype-0.2.1}/meson.build

@@ -13,27 +13,77 @@ if is_windows
   add_project_arguments('-DWIN32', '-D_WINDOWS', language : ['c', 'cpp'])
 endif
 
-sleef_dep = [
-  c.find_library('sleef', required : true),
-  c.find_library('sleefquad', required : true)
-]
+qblas_dep = dependency('qblas', fallback: ['qblas', 'qblas_dep'])
+
+sleef_subproj = subproject('sleef', required: true)
+sleef_dep = sleef_subproj.get_variable('sleef_dep')
+sleefquad_dep = sleef_subproj.get_variable('sleefquad_dep')
 
 incdir_numpy = run_command(py,
   ['-c', 'import numpy; print(numpy.get_include())'],
   check : true
 ).stdout().strip()
 
+npymath_path = incdir_numpy / '..' / 'lib'
+npymath_lib = c.find_library('npymath', dirs: npymath_path)
+
+dependencies = [py_dep, qblas_dep, sleef_dep, sleefquad_dep, npymath_lib]
+
 # Add OpenMP dependency (optional, for threading)
-openmp_dep = dependency('openmp', required: false)
-dependencies = [sleef_dep, py_dep]
+openmp_dep = dependency('openmp', required: false, static: false)
 if openmp_dep.found()
     dependencies += openmp_dep
 endif
 
+# compiler flags for QBLAS compatibility  
+if not is_windows
+    # QBLAS requires extended numeric literals for Q suffix support
+    # if compiler supports (usually gcc)
+    if cpp.has_argument('-fext-numeric-literals')
+        add_project_arguments('-fext-numeric-literals', language: 'cpp')
+    endif
+endif
+
+# Thread-local storage detection (borrowed from NumPy)
+optional_variable_attributes = [
+  ['thread_local', 'HAVE_THREAD_LOCAL'],    # C23
+  ['_Thread_local', 'HAVE__THREAD_LOCAL'],  # C11/C17
+  ['__thread', 'HAVE___THREAD'],           # GCC/Clang
+  ['__declspec(thread)', 'HAVE___DECLSPEC_THREAD_']  # MSVC
+]
+
+if not is_variable('cdata')
+  cdata = configuration_data()
+endif
+
+foreach optional_attr: optional_variable_attributes
+  attr = optional_attr[0]
+  code = '''
+    #pragma GCC diagnostic error "-Wattributes"
+    #pragma clang diagnostic error "-Wattributes"
+    
+    int @0@ foo;
+    
+    int main() {
+      return 0;
+    }
+  '''.format(attr)
+  
+  if c.compiles(code, name: optional_attr[0])
+    cdata.set10(optional_attr[1], true)
+    message('Thread-local storage support found: @0@'.format(attr))
+  endif
+endforeach
+
+configure_file(
+  output: 'quaddtype_config.h',
+  configuration: cdata
+)
+
+build_includes = include_directories('.') # compile time generated headers as per system
 includes = include_directories(
     [
         incdir_numpy,
-        'numpy_quaddtype/QBLAS/include',
         'numpy_quaddtype/src',
     ]
 )
@@ -79,10 +129,9 @@ py.install_sources(
 
 py.extension_module('_quaddtype_main',
   srcs,
-  link_args: is_windows ? ['/DEFAULTLIB:sleef', '/DEFAULTLIB:sleefquad'] : ['-lsleef', '-lsleefquad'],
   link_language: 'cpp',
   dependencies: dependencies,
   install: true,
   subdir: 'numpy_quaddtype',
-  include_directories: includes
+  include_directories: [includes, build_includes],
 )

{numpy_quaddtype-0.1.0 → numpy_quaddtype-0.2.1}/numpy_quaddtype/src/casts.cpp

@@ -9,6 +9,7 @@ extern "C" {
 #include <Python.h>
 
 #include "numpy/arrayobject.h"
+#include "numpy/halffloat.h"
 #include "numpy/ndarraytypes.h"
 #include "numpy/dtype_api.h"
 }
@@ -20,7 +21,7 @@ extern "C" {
 #include "casts.h"
 #include "dtype.h"
 
-#define NUM_CASTS 29  // 14 to_casts + 14 from_casts + 1 quad_to_quad
+#define NUM_CASTS 34  // 16 to_casts + 16 from_casts + 1 quad_to_quad + 1 void_to_quad
 
 static NPY_CASTING
 quad_to_quad_resolve_descriptors(PyObject *NPY_UNUSED(self),
@@ -30,9 +31,6 @@ quad_to_quad_resolve_descriptors(PyObject *NPY_UNUSED(self),
 {
     NPY_CASTING casting = NPY_NO_CASTING;
 
-    if (given_descrs[0]->backend != given_descrs[1]->backend)
-        casting = NPY_UNSAFE_CASTING;
-
     Py_INCREF(given_descrs[0]);
     loop_descrs[0] = given_descrs[0];
 
@@ -43,6 +41,9 @@ quad_to_quad_resolve_descriptors(PyObject *NPY_UNUSED(self),
     else {
         Py_INCREF(given_descrs[1]);
         loop_descrs[1] = given_descrs[1];
+        if (given_descrs[0]->backend != given_descrs[1]->backend) {
+            casting = NPY_UNSAFE_CASTING;
+        }
     }
 
     *view_offset = 0;
@@ -150,15 +151,48 @@ quad_to_quad_strided_loop_aligned(PyArrayMethod_Context *context, char *const da
     return 0;
 }
 
+
+static NPY_CASTING
+void_to_quad_resolve_descriptors(PyObject *NPY_UNUSED(self), PyArray_DTypeMeta *dtypes[2],
+                                PyArray_Descr *given_descrs[2], PyArray_Descr *loop_descrs[2],
+                                npy_intp *view_offset)
+{
+    PyErr_SetString(PyExc_TypeError, 
+        "Void to QuadPrecision cast is not implemented");
+    return (NPY_CASTING)-1;
+}
+
+static int
+void_to_quad_strided_loop(PyArrayMethod_Context *context, char *const data[],
+                         npy_intp const dimensions[], npy_intp const strides[],
+                         void *NPY_UNUSED(auxdata))
+{
+    PyErr_SetString(PyExc_RuntimeError, "void_to_quad_strided_loop should not be called");
+    return -1;
+}
+
+
+// Tag dispatching to ensure npy_bool/npy_ubyte and npy_half/npy_ushort do not alias in templates
+// see e.g. https://stackoverflow.com/q/32522279
+struct spec_npy_bool {};
+struct spec_npy_half {};
+
+template<typename T>
+struct NpyType { typedef T TYPE; };
+template<>
+struct NpyType<spec_npy_bool>{ typedef npy_bool TYPE; };
+template<>
+struct NpyType<spec_npy_half>{ typedef npy_half TYPE; };
+
 // Casting from other types to QuadDType
 
 template <typename T>
 static inline quad_value
-to_quad(T x, QuadBackendType backend);
+to_quad(typename NpyType<T>::TYPE x, QuadBackendType backend);
 
 template <>
 inline quad_value
-to_quad<npy_bool>(npy_bool x, QuadBackendType backend)
+to_quad<spec_npy_bool>(npy_bool x, QuadBackendType backend)
 {
     quad_value result;
     if (backend == BACKEND_SLEEF) {
@@ -184,6 +218,20 @@ to_quad<npy_byte>(npy_byte x, QuadBackendType backend)
     return result;
 }
 
+template <>
+inline quad_value
+to_quad<npy_ubyte>(npy_ubyte x, QuadBackendType backend)
+{
+    quad_value result;
+    if (backend == BACKEND_SLEEF) {
+        result.sleef_value = Sleef_cast_from_uint64q1(x);
+    }
+    else {
+        result.longdouble_value = (long double)x;
+    }
+    return result;
+}
+
 template <>
 inline quad_value
 to_quad<npy_short>(npy_short x, QuadBackendType backend)
@@ -295,6 +343,21 @@ to_quad<npy_ulonglong>(npy_ulonglong x, QuadBackendType backend)
     }
     return result;
 }
+
+template <>
+inline quad_value
+to_quad<spec_npy_half>(npy_half x, QuadBackendType backend)
+{
+    quad_value result;
+    if (backend == BACKEND_SLEEF) {
+        result.sleef_value = Sleef_cast_from_doubleq1(npy_half_to_double(x));
+    }
+    else {
+        result.longdouble_value = (long double)npy_half_to_double(x);
+    }
+    return result;
+}
+
 template <>
 inline quad_value
 to_quad<float>(float x, QuadBackendType backend)
@@ -374,10 +437,10 @@ numpy_to_quad_strided_loop_unaligned(PyArrayMethod_Context *context, char *const
     size_t elem_size = (backend == BACKEND_SLEEF) ? sizeof(Sleef_quad) : sizeof(long double);
 
     while (N--) {
-        T in_val;
+        typename NpyType<T>::TYPE in_val;
         quad_value out_val;
 
-        memcpy(&in_val, in_ptr, sizeof(T));
+        memcpy(&in_val, in_ptr, sizeof(typename NpyType<T>::TYPE));
         out_val = to_quad<T>(in_val, backend);
         memcpy(out_ptr, &out_val, elem_size);
 
@@ -401,7 +464,7 @@ numpy_to_quad_strided_loop_aligned(PyArrayMethod_Context *context, char *const d
     QuadBackendType backend = descr_out->backend;
 
     while (N--) {
-        T in_val = *(T *)in_ptr;
+        typename NpyType<T>::TYPE in_val = *(typename NpyType<T>::TYPE *)in_ptr;
         quad_value out_val = to_quad<T>(in_val, backend);
 
         if (backend == BACKEND_SLEEF) {
@@ -420,12 +483,12 @@ numpy_to_quad_strided_loop_aligned(PyArrayMethod_Context *context, char *const d
 // Casting from QuadDType to other types
 
 template <typename T>
-static inline T
+static inline typename NpyType<T>::TYPE
 from_quad(quad_value x, QuadBackendType backend);
 
 template <>
 inline npy_bool
-from_quad<npy_bool>(quad_value x, QuadBackendType backend)
+from_quad<spec_npy_bool>(quad_value x, QuadBackendType backend)
 {
     if (backend == BACKEND_SLEEF) {
         return Sleef_cast_to_int64q1(x.sleef_value) != 0;
@@ -447,6 +510,18 @@ from_quad<npy_byte>(quad_value x, QuadBackendType backend)
     }
 }
 
+template <>
+inline npy_ubyte
+from_quad<npy_ubyte>(quad_value x, QuadBackendType backend)
+{
+    if (backend == BACKEND_SLEEF) {
+        return (npy_ubyte)Sleef_cast_to_uint64q1(x.sleef_value);
+    }
+    else {
+        return (npy_ubyte)x.longdouble_value;
+    }
+}
+
 template <>
 inline npy_short
 from_quad<npy_short>(quad_value x, QuadBackendType backend)
@@ -543,6 +618,18 @@ from_quad<npy_ulonglong>(quad_value x, QuadBackendType backend)
     }
 }
 
+template <>
+inline npy_half
+from_quad<spec_npy_half>(quad_value x, QuadBackendType backend)
+{
+    if (backend == BACKEND_SLEEF) {
+        return npy_double_to_half(Sleef_cast_to_doubleq1(x.sleef_value));
+    }
+    else {
+        return npy_double_to_half((double)x.longdouble_value);
+    }
+}
+
 template <>
 inline float
 from_quad<float>(quad_value x, QuadBackendType backend)
@@ -611,8 +698,8 @@ quad_to_numpy_strided_loop_unaligned(PyArrayMethod_Context *context, char *const
         quad_value in_val;
         memcpy(&in_val, in_ptr, elem_size);
 
-        T out_val = from_quad<T>(in_val, backend);
-        memcpy(out_ptr, &out_val, sizeof(T));
+        typename NpyType<T>::TYPE out_val = from_quad<T>(in_val, backend);
+        memcpy(out_ptr, &out_val, sizeof(typename NpyType<T>::TYPE));
 
         in_ptr += strides[0];
         out_ptr += strides[1];
@@ -642,8 +729,8 @@ quad_to_numpy_strided_loop_aligned(PyArrayMethod_Context *context, char *const d
             in_val.longdouble_value = *(long double *)in_ptr;
         }
 
-        T out_val = from_quad<T>(in_val, backend);
-        *(T *)(out_ptr) = out_val;
+        typename NpyType<T>::TYPE out_val = from_quad<T>(in_val, backend);
+        *(typename NpyType<T>::TYPE *)(out_ptr) = out_val;
 
         in_ptr += strides[0];
         out_ptr += strides[1];
@@ -739,8 +826,27 @@ init_casts_internal(void)
 
     add_spec(quad2quad_spec);
 
-    add_cast_to<npy_bool>(&PyArray_BoolDType);
+    PyArray_DTypeMeta **void_dtypes = new PyArray_DTypeMeta *[2]{&PyArray_VoidDType, &QuadPrecDType};
+    PyType_Slot *void_slots = new PyType_Slot[]{
+        {NPY_METH_resolve_descriptors, (void *)&void_to_quad_resolve_descriptors},
+        {NPY_METH_strided_loop, (void *)&void_to_quad_strided_loop},
+        {NPY_METH_unaligned_strided_loop, (void *)&void_to_quad_strided_loop},
+        {0, nullptr}};
+
+    PyArrayMethod_Spec *void_spec = new PyArrayMethod_Spec{
+        .name = "cast_Void_to_QuadPrec_ERROR",
+        .nin = 1,
+        .nout = 1,
+        .casting = NPY_UNSAFE_CASTING,
+        .flags = NPY_METH_SUPPORTS_UNALIGNED,
+        .dtypes = void_dtypes,
+        .slots = void_slots,
+    };
+    add_spec(void_spec);
+
+    add_cast_to<spec_npy_bool>(&PyArray_BoolDType);
     add_cast_to<npy_byte>(&PyArray_ByteDType);
+    add_cast_to<npy_ubyte>(&PyArray_UByteDType);
     add_cast_to<npy_short>(&PyArray_ShortDType);
     add_cast_to<npy_ushort>(&PyArray_UShortDType);
     add_cast_to<npy_int>(&PyArray_IntDType);
@@ -749,12 +855,14 @@ init_casts_internal(void)
     add_cast_to<npy_ulong>(&PyArray_ULongDType);
     add_cast_to<npy_longlong>(&PyArray_LongLongDType);
     add_cast_to<npy_ulonglong>(&PyArray_ULongLongDType);
+    add_cast_to<spec_npy_half>(&PyArray_HalfDType);
     add_cast_to<float>(&PyArray_FloatDType);
     add_cast_to<double>(&PyArray_DoubleDType);
     add_cast_to<long double>(&PyArray_LongDoubleDType);
 
-    add_cast_from<npy_bool>(&PyArray_BoolDType);
+    add_cast_from<spec_npy_bool>(&PyArray_BoolDType);
     add_cast_from<npy_byte>(&PyArray_ByteDType);
+    add_cast_from<npy_ubyte>(&PyArray_UByteDType);
     add_cast_from<npy_short>(&PyArray_ShortDType);
     add_cast_from<npy_ushort>(&PyArray_UShortDType);
     add_cast_from<npy_int>(&PyArray_IntDType);
@@ -763,6 +871,7 @@ init_casts_internal(void)
     add_cast_from<npy_ulong>(&PyArray_ULongDType);
     add_cast_from<npy_longlong>(&PyArray_LongLongDType);
     add_cast_from<npy_ulonglong>(&PyArray_ULongLongDType);
+    add_cast_from<spec_npy_half>(&PyArray_HalfDType);
     add_cast_from<float>(&PyArray_FloatDType);
     add_cast_from<double>(&PyArray_DoubleDType);
     add_cast_from<long double>(&PyArray_LongDoubleDType);

{numpy_quaddtype-0.1.0 → numpy_quaddtype-0.2.1}/numpy_quaddtype/src/dragon4.c

@@ -11,6 +11,9 @@ Modifications are specific to support the SLEEF_QUAD
 #include <sleef.h>
 #include <sleefquad.h>
 
+#include "quaddtype_config.h"
+
+
 #define PY_ARRAY_UNIQUE_SYMBOL QuadPrecType_ARRAY_API
 #define PY_UFUNC_UNIQUE_SYMBOL QuadPrecType_UFUNC_API
 #define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
@@ -22,6 +25,21 @@ Modifications are specific to support the SLEEF_QUAD
 #include "dtype.h"
 #include "scalar.h"
 
+
+#ifdef __cplusplus
+    #define NPY_TLS thread_local
+#elif defined(HAVE_THREAD_LOCAL)
+    #define NPY_TLS thread_local
+#elif defined(HAVE__THREAD_LOCAL)
+    #define NPY_TLS _Thread_local
+#elif defined(HAVE___THREAD)
+    #define NPY_TLS __thread
+#elif defined(HAVE___DECLSPEC_THREAD_)
+    #define NPY_TLS __declspec(thread)
+#else
+    #define NPY_TLS
+#endif
+
 #if 0
 #define DEBUG_ASSERT(stmnt) assert(stmnt)
 #else