numexpr 2.10.2__cp313-cp313-win_amd64.whl

numexpr/interpreter.hpp

@@ -0,0 +1,107 @@
+#ifndef NUMEXPR_INTERPRETER_HPP
+#define NUMEXPR_INTERPRETER_HPP
+
+#include "numexpr_config.hpp"
+
+// Forward declaration
+struct NumExprObject;
+
+enum OpCodes {
+#define OPCODE(n, e, ...) e = n,
+#include "opcodes.hpp"
+#undef OPCODE
+};
+
+enum FuncFFCodes {
+#define FUNC_FF(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_FF
+};
+
+enum FuncFFFCodes {
+#define FUNC_FFF(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_FFF
+};
+
+enum FuncDDCodes {
+#define FUNC_DD(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_DD
+};
+
+enum FuncDDDCodes {
+#define FUNC_DDD(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_DDD
+};
+
+enum FuncCCCodes {
+#define FUNC_CC(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_CC
+};
+
+enum FuncCCCCodes {
+#define FUNC_CCC(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_CCC
+};
+
+struct vm_params {
+    int prog_len;
+    unsigned char *program;
+    int n_inputs;
+    int n_constants;
+    int n_temps;
+    unsigned int r_end;
+    char *output;
+    char **inputs;
+    char **mem;
+    npy_intp *memsteps;
+    npy_intp *memsizes;
+    struct index_data *index_data;
+    // Memory for output buffering. If output buffering is unneeded,
+    // it contains NULL.
+    char *out_buffer;
+};
+
+// Structure for parameters in worker threads
+struct thread_data {
+    npy_intp start;
+    npy_intp vlen;
+    npy_intp block_size;
+    vm_params params;
+    int ret_code;
+    int *pc_error;
+    char **errmsg;
+    // NOTE: memsteps, iter, and reduce_iter are arrays, they MUST be allocated 
+    // to length `global_max_threads` before module load.
+    // One memsteps array per thread
+    // npy_intp *memsteps[MAX_THREADS];
+    npy_intp **memsteps;
+    // One iterator per thread */
+    // NpyIter *iter[MAX_THREADS];
+    NpyIter **iter;
+    // When doing nested iteration for a reduction
+    // NpyIter *reduce_iter[MAX_THREADS]
+    NpyIter **reduce_iter;
+    // Flag indicating reduction is the outer loop instead of the inner
+    bool reduction_outer_loop;
+    // Flag indicating whether output buffering is needed
+    bool need_output_buffering;
+};
+
+// Global state which holds thread parameters
+extern thread_data th_params;
+
+PyObject *NumExpr_run(NumExprObject *self, PyObject *args, PyObject *kwds);
+
+char get_return_sig(PyObject* program);
+int check_program(NumExprObject *self);
+int get_temps_space(const vm_params& params, char **mem, size_t block_size);
+void free_temps_space(const vm_params& params, char **mem);
+int vm_engine_iter_task(NpyIter *iter, npy_intp *memsteps,
+                    const vm_params& params, int *pc_error, char **errmsg);
+
+#endif // NUMEXPR_INTERPRETER_HPP

numexpr/missing_posix_functions.hpp

@@ -0,0 +1,102 @@
+#ifndef NUMEXPR_MISSING_POSIX_FUNCTIONS_HPP
+#define NUMEXPR_MISSING_POSIX_FUNCTIONS_HPP
+
+/*********************************************************************
+  Numexpr - Fast numerical array expression evaluator for NumPy.
+
+      License: MIT
+      Author:  See AUTHORS.txt
+
+  See LICENSE.txt for details about copyright and rights to use.
+**********************************************************************/
+
+/* These functions are not included in some non-POSIX compilers,
+  like MSVC 7.1  */
+
+
+/* Double precision versions */
+
+inline double log1p(double x)
+{
+    double u = 1.0 + x;
+    if (u == 1.0) {
+        return x;
+    } else {
+        return log(u) * x / (u-1.0);
+    }
+}
+
+inline double expm1(double x)
+{
+    double u = exp(x);
+    if (u == 1.0) {
+        return x;
+    } else if (u-1.0 == -1.0) {
+        return -1;
+    } else {
+        return (u-1.0) * x/log(u);
+    }
+}
+
+inline double asinh(double xx)
+{
+    double x, d;
+    int sign;
+    if (xx < 0.0) {
+        sign = -1;
+        x = -xx;
+    }
+    else {
+        sign = 1;
+        x = xx;
+    }
+    if (x > 1e8) {
+        d = x;
+    } else {
+        d = sqrt(x*x + 1.0);
+    }
+    return sign*log1p(x*(1.0 + x/(d+1.0)));
+}
+
+inline double acosh(double x)
+{
+    return 2*log(sqrt((x+1.0)/2)+sqrt((x-1.0)/2));
+}
+
+inline double atanh(double x)
+{
+    /* This definition is different from that in NumPy 1.3 and follows
+    the convention of MatLab.  This will allow for double checking both
+    approaches. */
+    return 0.5*log((1.0+x)/(1.0-x));
+}
+
+
+/* Single precision versions */
+
+inline float log1pf(float x)
+{
+    return (float) log1p((double)x);
+}
+
+inline float expm1f(float x)
+{
+    return (float) expm1((double)x);
+}
+
+inline float asinhf(float x)
+{
+    return (float) asinh((double)x);
+}
+
+inline float acoshf(float x)
+{
+    return (float) acosh((double)x);
+}
+
+inline float atanhf(float x)
+{
+    return (float) atanh((double)x);
+}
+
+#endif // NUMEXPR_MISSING_POSIX_FUNCTIONS_HPP