#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include <structmember.h>

#include <ctype.h>

#define NPY_NO_DEPRECATED_API NPY_API_VERSION

#ifndef _MULTIARRAYMODULE

#define _MULTIARRAYMODULE

#include "numpy/arrayobject.h"

#include "numpy/npy_math.h"

#include "numpy/halffloat.h"

#include "numpy/arrayscalars.h"

#include "npy_pycompat.h"

#include "arraytypes.h"

#include "array_coercion.h"

#include "npy_config.h"

#include "mapping.h"

#include "ctors.h"

#include "dtypemeta.h"

#include "descriptor.h"

#include "usertypes.h"

#include "number.h"

#include "numpyos.h"

#include "can_cast_table.h"

#include "common.h"

#include "conversion_utils.h"

#include "flagsobject.h"

#include "scalartypes.h"

#include "_datetime.h"

#include "datetime_strings.h"

#include "alloc.h"

#include "npy_import.h"

#include "dragon4.h"

#include "npy_longdouble.h"

#include "npy_buffer.h"

#include "npy_dlpack.h"

#include "npy_static_data.h"

#include "module_state.h"

#include "multiarraymodule.h"

#include "array_api_standard.h"

#include <stdlib.h>

#include "binop_override.h"

NPY_NO_EXPORT void *

npy_alloc_cache_zero(size_t nmemb, size_t size);

NPY_NO_EXPORT void

npy_free_cache(void * p, npy_uintp sz);

NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[] = {

{PyObject_HEAD_INIT(&PyBoolArrType_Type) 0},

{PyObject_HEAD_INIT(&PyBoolArrType_Type) 1},

};

NPY_NO_EXPORT PyTypeObject PyTimeIntegerArrType_Type;

NPY_NO_EXPORT PyTypeObject Py@NAME@ArrType_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

.tp_name = "numpy.@name@",

.tp_basicsize = sizeof(PyObject),

};

static void

gentype_dealloc(PyObject *v)

{

Py_TYPE(v)->tp_free(v);

}

static void

gentype_free(PyObject *v)

{

/*

PyObject_Free(v);

}

#define NPY_SCALAR_METHOD_NAME(name) \

(_npy_module_state->interned_str \

.scalar_method_names[NPY_SCALAR_METHOD_##name])

#define NPY_SCALAR_FORWARD_STACK_SIZE 10

static PyObject *

gentype_generic_vectorcall(PyObject *self, PyObject *const *args,

Py_ssize_t len_args, PyObject *kwnames, PyObject *name)

{

PyObject *arr = PyArray_FromScalar(self, NULL);

if (arr == NULL) {

return NULL;

}

Py_ssize_t nargs = len_args;

if (kwnames != NULL) {

nargs += PyTuple_GET_SIZE(kwnames);

}

NPY_ALLOC_WORKSPACE(stack, PyObject *, NPY_SCALAR_FORWARD_STACK_SIZE,

nargs + 1);

if (stack == NULL) {

Py_DECREF(arr);

return NULL;

}

stack[0] = arr;

if (nargs > 0) {

memcpy(stack + 1, args, nargs * sizeof(PyObject *));

}

PyObject *ret = PyObject_VectorcallMethod(name, stack,

((size_t)len_args + 1) | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);

npy_free_workspace(stack);

Py_DECREF(arr);

if (ret != NULL && PyArray_Check(ret)) {

return PyArray_Return((PyArrayObject *)ret);

}

return ret;

}

static inline int

find_binary_operation_path(

PyObject *self, PyObject *other, PyObject **self_op, PyObject **other_op)

{

multiarray_umath_state *state = _npy_module_state;

*other_op = NULL;

*self_op = NULL;

if (PyArray_IsScalar(other, Generic) ||

PyLong_CheckExact(other) ||

PyFloat_CheckExact(other) ||

PyComplex_CheckExact(other) ||

PyBool_Check(other) ||

PyArray_Check(other)) {

/*

*other_op = Py_NewRef(other);

return 0;

}

/*

PyObject *attr;

if (PyArray_LookupSpecial(other, state->interned_str.array_ufunc, &attr) < 0) {

PyErr_Clear(); /* TODO[gh-14801]: propagate crashes during attribute access? */

}

else if (attr != NULL) {

Py_DECREF(attr);

*other_op = Py_NewRef(other);

return 0;

}

/*

int was_scalar;

PyArrayObject *arr = (PyArrayObject *)PyArray_FromAny_int(

other, NULL, NULL, 0, NPY_MAXDIMS, 0, &was_scalar);

if (arr == NULL) {

return -1;

}

if (!was_scalar || PyArray_DESCR(arr)->type_num != NPY_OBJECT) {

/*

*other_op = (PyObject *)arr;

return 0;

}

Py_DECREF(arr);

/*

PyObject *self_item = PyObject_VectorcallMethod(

state->interned_str.item, &self, 1, NULL);

if (self_item == NULL) {

return -1;

}

if (Py_TYPE(self_item) != Py_TYPE(self)) {

/* self_item can be used to retry the operation */

*self_op = self_item;

return 0;

}

/* The operation can't work and we will return NotImplemented */

Py_DECREF(self_item);

return 0;

}

static PyObject *

gentype_add(PyObject *m1, PyObject *m2);

static PyObject *

gentype_multiply(PyObject *m1, PyObject *m2);

static PyObject *

gentype_@name@@suff@(PyObject *m1, PyObject *m2)

{

multiarray_umath_state *state = _npy_module_state;

BINOP_GIVE_UP_IF_NEEDED(m1, m2, nb_@name@, gentype_@name@);

PyObject *self = NULL;

PyObject *other = NULL;

PyObject *self_op, *other_op;

if (!PyArray_IsScalar(m2, Generic)) {

self = m1;

other = m2;

}

else {

self = m2;

other = m1;

}

if (find_binary_operation_path(self, other, &self_op, &other_op) < 0) {

return NULL;

}

if (self_op != NULL) {

PyObject *res;

if (self == m1) {

res = PyNumber_@func@(self_op, m2);

}

else {

res = PyNumber_@func@(m1, self_op);

}

Py_DECREF(self_op);

return res;

}

else if (other_op != NULL) {

/* Call the corresponding ufunc (with the array) */

PyObject *res;

if (self == m1) {

res = PyArray_GenericBinaryFunction(m1, other_op, state->n_ops.@ufunc@);

}

else {

res = PyArray_GenericBinaryFunction(other_op, m2, state->n_ops.@ufunc@);

}

Py_DECREF(other_op);

return res;

}

else {

assert(other_op == NULL);

Py_RETURN_NOTIMPLEMENTED;

}

}

static PyObject *

gentype_add(PyObject *m1, PyObject *m2)

{

/* special case str.__radd__, which should not call array_add */

if (PyBytes_Check(m1) || PyUnicode_Check(m1)) {

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

return gentype_add_gen(m1, m2);

}

#define GET_NESTED_SLOT(type, group, slot) \

((type)->group == NULL ? NULL : (type)->group->slot)

static PyObject *

gentype_multiply(PyObject *m1, PyObject *m2)

{

/*

if (!PyArray_IsScalar(m1, Generic) &&

GET_NESTED_SLOT(Py_TYPE(m1), tp_as_sequence, sq_repeat) != NULL &&

GET_NESTED_SLOT(Py_TYPE(m1), tp_as_number, nb_multiply) == NULL) {

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

if (!PyArray_IsScalar(m2, Generic) &&

GET_NESTED_SLOT(Py_TYPE(m2), tp_as_sequence, sq_repeat) != NULL &&

GET_NESTED_SLOT(Py_TYPE(m2), tp_as_number, nb_multiply) == NULL) {

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

return gentype_multiply_gen(m1, m2);

}

static PyObject *

gentype_power(PyObject *m1, PyObject *m2, PyObject *modulo)

{

multiarray_umath_state *state = _npy_module_state;

if (modulo != Py_None) {

/* modular exponentiation is not implemented (gh-8804) */

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

BINOP_GIVE_UP_IF_NEEDED(m1, m2, nb_power, gentype_power);

PyObject *self = NULL;

PyObject *other = NULL;

PyObject *self_op, *other_op;

if (!PyArray_IsScalar(m2, Generic)) {

self = m1;

other = m2;

}

else {

self = m2;

other = m1;

}

if (find_binary_operation_path(self, other, &self_op, &other_op) < 0) {

return NULL;

}

if (self_op != NULL) {

PyObject *res;

if (self == m1) {

res = PyNumber_Power(self_op, m2, Py_None);

}

else {

res = PyNumber_Power(m1, self_op, Py_None);

}

Py_DECREF(self_op);

return res;

}

else if (other_op != NULL) {

/* Call the corresponding ufunc (with the array)

PyObject *res;

if (self == m1) {

res = PyArray_GenericBinaryFunction(m1, other_op, state->n_ops.power);

}

else {

res = PyArray_GenericBinaryFunction(other_op, m2, state->n_ops.power);

}

Py_DECREF(other_op);

return res;

}

else {

assert(other_op == NULL);

Py_RETURN_NOTIMPLEMENTED;

}

}

static PyObject *

@type@_bit_count(PyObject *self, PyObject *NPY_UNUSED(args))

{

@type@ scalar = PyArrayScalar_VAL(self, @Name@);

uint8_t count = npy_popcount@c@(scalar);

PyObject *result = PyLong_From@convert@(count);

return result;

}

static PyObject *

gentype_@name@(PyObject *m1)

{

PyObject *arr, *ret;

arr = PyArray_FromScalar(m1, NULL);

if (arr == NULL) {

return NULL;

}

ret = Py_TYPE(arr)->tp_as_number->nb_@name@(arr);

Py_DECREF(arr);

return ret;

}

static int

gentype_nonzero_number(PyObject *m1)

{

PyObject *arr;

int ret;

arr = PyArray_FromScalar(m1, NULL);

if (arr == NULL) {

return -1;

}

ret = Py_TYPE(arr)->tp_as_number->nb_bool(arr);

Py_DECREF(arr);

return ret;

}

static PyObject *

genint_type_str(PyObject *self)

{

PyObject *item, *item_str;

PyArray_Descr *dtype = PyArray_DescrFromTypeObject((PyObject *)Py_TYPE(self));

void *val = scalar_value(self, dtype);

switch (dtype->type_num) {

case NPY_BYTE:

item = PyLong_FromLong(*(npy_byte *)val);

break;

case NPY_UBYTE:

item = PyLong_FromUnsignedLong(*(npy_ubyte *)val);

break;

case NPY_SHORT:

item = PyLong_FromLong(*(npy_short *)val);

break;

case NPY_USHORT:

item = PyLong_FromUnsignedLong(*(npy_ushort *)val);

break;

case NPY_INT:

item = PyLong_FromLong(*(npy_int *)val);

break;

case NPY_UINT:

item = PyLong_FromUnsignedLong(*(npy_uint *)val);

break;

case NPY_LONG:

item = PyLong_FromLong(*(npy_long *)val);

break;

case NPY_ULONG:

item = PyLong_FromUnsignedLong(*(npy_ulong *)val);

break;

case NPY_LONGLONG:

item = PyLong_FromLongLong(*(npy_longlong *)val);

break;

case NPY_ULONGLONG:

item = PyLong_FromUnsignedLongLong(*(npy_ulonglong *)val);

break;

default:

item = gentype_generic_vectorcall(self, NULL, 0, NULL,

NPY_SCALAR_METHOD_NAME(item));

break;

}

Py_DECREF(dtype);

if (item == NULL) {

return NULL;

}

item_str = PyObject_Str(item);

Py_DECREF(item);

return item_str;

}

static PyObject *

genint_type_repr(PyObject *self)

{

PyObject *value_string = genint_type_str(self);

if (value_string == NULL) {

return NULL;

}

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode <= 125) {

return value_string;

}

int num = _typenum_fromtypeobj((PyObject *)Py_TYPE(self), 0);

PyObject *repr;

if (num == NPY_NOTYPE) {

/* Not a builtin scalar (presumably), just use the name */

repr = PyUnicode_FromFormat("%s(%S)", Py_TYPE(self)->tp_name, value_string);

Py_DECREF(value_string);

return repr;

}

PyArray_Descr *descr = PyArray_DescrFromType(num); /* cannot fail */

int bitsize = descr->elsize * 8;

Py_DECREF(descr);

if (PyTypeNum_ISUNSIGNED(num)) {

repr = PyUnicode_FromFormat("np.uint%d(%S)", bitsize, value_string);

}

else {

repr = PyUnicode_FromFormat("np.int%d(%S)", bitsize, value_string);

}

Py_DECREF(value_string);

return repr;

}

static PyObject *

genbool_type_str(PyObject *self)

{

return PyUnicode_FromString(

((PyBoolScalarObject *)self)->obval ? "True" : "False");

}

static PyObject *

genbool_type_repr(PyObject *self)

{

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode <= 125) {

return genbool_type_str(self);

}

return PyUnicode_FromString(

((PyBoolScalarObject *)self)->obval ? "np.True_" : "np.False_");

}

static PyObject *

gentype_format(PyObject *self, PyObject *args)

{

PyObject *format_spec;

PyObject *obj, *ret;

if (!PyArg_ParseTuple(args, "U:__format__", &format_spec)) {

return NULL;

}

/*

if (Py_TYPE(self) == &PyBoolArrType_Type) {

obj = PyBool_FromLong(PyArrayScalar_VAL(self, Bool));

}

else if (PyArray_IsScalar(self, Integer)

&& !PyArray_IsScalar(self, Timedelta)) {

obj = Py_TYPE(self)->tp_as_number->nb_int(self);

}

else if (PyArray_IsScalar(self, Floating)) {

obj = Py_TYPE(self)->tp_as_number->nb_float(self);

}

else if (PyArray_IsScalar(self, ComplexFloating)) {

double val[2];

PyArray_Descr *dtype = PyArray_DescrFromScalar(self);

if (dtype == NULL) {

return NULL;

}

if (PyArray_CastScalarDirect(self, dtype, &val[0], NPY_CDOUBLE) < 0) {

Py_DECREF(dtype);

return NULL;

}

obj = PyComplex_FromDoubles(val[0], val[1]);

Py_DECREF(dtype);

}

else {

obj = PyObject_Str(self);

}

if (obj == NULL) {

return NULL;

}

ret = PyObject_Format(obj, format_spec);

Py_DECREF(obj);

return ret;

}

#ifdef FORCE_NO_LONG_DOUBLE_FORMATTING

#undef NPY_LONGDOUBLE_FMT

#define NPY_LONGDOUBLE_FMT NPY_DOUBLE_FMT

NPY_NO_EXPORT PyObject *

format_@name@(@type@ val, npy_bool scientific,

int precision, int sign, TrimMode trim,

int pad_left, int pad_right, int exp_digits)

{

if (scientific) {

return Dragon4_Scientific_@Name@(&val,

DigitMode_Unique, precision, -1,

sign, trim, pad_left, exp_digits);

}

else {

return Dragon4_Positional_@Name@(&val,

DigitMode_Unique, CutoffMode_TotalLength, precision,

-1, sign, trim, pad_left, pad_right);

}

}

#define IS_@form@

static PyObject *

stringtype_@form@(PyObject *self)

{

const npy_char *dptr, *ip;

Py_ssize_t len;

PyObject *new;

PyObject *ret;

ip = PyBytes_AS_STRING(self);

len = PyBytes_GET_SIZE(self);

for(dptr = ip + len - 1; len > 0 && *dptr == 0; len--, dptr--);

new = PyBytes_FromStringAndSize(ip, len);

if (new == NULL) {

return NULL;

}

ret = PyBytes_Type.tp_@form@(new);

Py_DECREF(new);

#ifdef IS_repr

if (ret == NULL) {

return NULL;

}

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode > 125) {

Py_SETREF(ret, PyUnicode_FromFormat("np.bytes_(%S)", ret));

}

#endif /* IS_repr */

return ret;

}

#undef IS_@form@

#define IS_@form@

static PyObject *

unicodetype_@form@(PyObject *self)

{

Py_UCS4 *dptr, *ip;

Py_ssize_t len;

PyObject *new;

PyObject *ret;

/* PyUnicode_READY is called by PyUnicode_GetLength */

len = PyUnicode_GetLength(self);

ip = PyUnicode_AsUCS4Copy(self);

if (ip == NULL) {

return NULL;

}

for(dptr = ip + len - 1; len > 0 && *dptr == 0; len--, dptr--);

new = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, ip, len);

if (new == NULL) {

PyMem_Free(ip);

return NULL;

}

ret = PyUnicode_Type.tp_@form@(new);

Py_DECREF(new);

PyMem_Free(ip);

#ifdef IS_repr

if (ret == NULL) {

return NULL;

}

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode > 125) {

Py_SETREF(ret, PyUnicode_FromFormat("np.str_(%S)", ret));

}

#endif /* IS_repr */

return ret;

}

#undef IS_@form@

static inline PyObject *

_void_to_hex(const char* argbuf, const Py_ssize_t arglen,

const char *schars, const char *bprefix, const char *echars)

{

PyObject *retval;

Py_ssize_t i, j, extrachars, slen;

char *retbuf;

char const *hexdigits = "0123456789ABCDEF";

extrachars = strlen(schars) + strlen(echars);

slen = extrachars + arglen*(2 + strlen(bprefix));

if (arglen > (PY_SSIZE_T_MAX / 2) - extrachars) {

return PyErr_NoMemory();

}

retbuf = (char *)PyMem_Malloc(slen);

if (!retbuf) {

return PyErr_NoMemory();

}

memcpy(retbuf, schars, strlen(schars));

j = strlen(schars);

for (i = 0; i < arglen; i++) {

unsigned char c;

memcpy(&retbuf[j], bprefix, strlen(bprefix));

j += strlen(bprefix);

c = (argbuf[i] >> 4) & 0xf;

retbuf[j++] = hexdigits[c];

c = argbuf[i] & 0xf;

retbuf[j++] = hexdigits[c];

}

memcpy(&retbuf[j], echars, strlen(echars));

retval = PyUnicode_FromStringAndSize(retbuf, slen);

PyMem_Free(retbuf);

return retval;

}

static PyObject *

_void_scalar_to_string(PyObject *obj, int repr) {

multiarray_umath_state *state = _npy_module_state;

if (npy_cache_import_runtime(

"numpy._core.arrayprint", "_void_scalar_to_string",

&state->runtime_imports._void_scalar_to_string) == -1) {

return NULL;

}

PyObject *is_repr = repr ? Py_True : Py_False;

return PyObject_CallFunctionObjArgs(

state->runtime_imports._void_scalar_to_string, obj, is_repr, NULL);

}

static PyObject *

voidtype_repr(PyObject *self)

{

PyVoidScalarObject *s = (PyVoidScalarObject*) self;

if (PyDataType_HASFIELDS(s->descr)) {

/* Python helper checks for the legacy mode printing */

return _void_scalar_to_string(self, 1);

}

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode > 125) {

return _void_to_hex(s->obval, s->descr->elsize, "np.void(b'", "\\x", "')");

}

else {

return _void_to_hex(s->obval, s->descr->elsize, "void(b'", "\\x", "')");

}

}

static PyObject *

voidtype_str(PyObject *self)

{

PyVoidScalarObject *s = (PyVoidScalarObject*) self;

if (PyDataType_HASFIELDS(s->descr)) {

return _void_scalar_to_string(self, 0);

}

return _void_to_hex(s->obval, s->descr->elsize, "b'", "\\x", "'");

}

static PyObject *

datetimetype_repr(PyObject *self)

{

PyDatetimeScalarObject *scal;

npy_datetimestruct dts;

PyObject *ret;

char iso[NPY_DATETIME_MAX_ISO8601_STRLEN];

NPY_DATETIMEUNIT unit;

if (!PyArray_IsScalar(self, Datetime)) {

PyErr_SetString(PyExc_RuntimeError,

"Called NumPy datetime repr on a non-datetime type");

return NULL;

}

scal = (PyDatetimeScalarObject *)self;

if (NpyDatetime_ConvertDatetime64ToDatetimeStruct(&scal->obmeta,

scal->obval, &dts) < 0) {

return NULL;

}

unit = scal->obmeta.base;

if (NpyDatetime_MakeISO8601Datetime(&dts, iso, sizeof(iso), 0, 0,

unit, -1, NPY_SAFE_CASTING) < 0) {

return NULL;

}

/*

if ((scal->obmeta.num == 1 && scal->obmeta.base != NPY_FR_h) ||

scal->obmeta.base == NPY_FR_GENERIC) {

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

PyObject *meta = metastr_to_unicode(&scal->obmeta, 1);

if((scal->obval == NPY_DATETIME_NAT) && (meta != NULL)){

if (legacy_print_mode > 125) {

ret = PyUnicode_FromFormat("np.datetime64('%s','%S')", iso, meta);

} else {

ret = PyUnicode_FromFormat("numpy.datetime64('%s','%S')", iso, meta);

}

} else {

if (legacy_print_mode > 125) {

ret = PyUnicode_FromFormat("np.datetime64('%s')", iso);

}

else {

ret = PyUnicode_FromFormat("numpy.datetime64('%s')", iso);

}

}

Py_DECREF(meta);

}

else {

PyObject *meta = metastr_to_unicode(&scal->obmeta, 1);

if (meta == NULL) {

return NULL;

}

int legacy_print_mode = get_legacy_print_mode();

if (legacy_print_mode == -1) {

return NULL;

}

if (legacy_print_mode > 125) {

ret = PyUnicode_FromFormat("np.datetime64('%s','%S')", iso, meta);

}

else {

ret = PyUnicode_FromFormat("numpy.datetime64('%s','%S')", iso, meta);

}

Py_DECREF(meta);

}

return ret;

}

static PyObject *

timedeltatype_repr(PyObject *self)

{

PyTimedeltaScalarObject *scal;

PyObject *val, *ret;

if (!PyArray_IsScalar(self, Timedelta)) {

PyErr_SetString(PyExc_RuntimeError,

"Called NumPy timedelta repr on a non-datetime type");

return NULL;

}

scal = (PyTimedeltaScalarObject *)self;

/* The value */

if (scal->obval == NPY_DATETIME_NAT) {

val = PyUnicode_FromString("'NaT'");

}